{
"cells": [
{
"cell_type": "markdown",
"id": "0351c520-80dd-4f05-a4e1-86c05dc15ab5",
"metadata": {},
"source": [
"# Queue-Based Market Making in Large Tick Size Assets\n",
"\n",
"## Overview\n",
"The significance of queue position is well-known in microstructure trading, particularly in assets with large tick sizes. This is because larger tick assets typically more constrained price movements. The impact of tick size is discussed in detail in [\"Large tick assets: implicit spread and optimal tick size\"](https://arxiv.org/pdf/1207.6325).\n",
"\n",
"\n",
"\n",
"
\n",
" \n",
"**Note:** This example is for educational purposes only and demonstrates effective strategies for high-frequency market-making schemes. All backtests are based on a 0.005% rebate, the highest market maker rebate available on Binance Futures. See Binance Upgrades USDⓢ-Margined Futures Liquidity Provider Program for more details.\n",
" \n",
"
\n",
"\n",
"## Book Pressure\n",
"To begin, we will review the [Market Microstructure signals described in this article](https://blog.headlandstech.com/2017/08/), which are similar to the concept of micro-price. Book imbalance is also addressed in [Market Making with Alpha - Order Book Imbalance](https://github.com/nkaz001/hftbacktest/blob/master/examples/Market%20Making%20with%20Alpha%20-%20Order%20Book%20Imbalance.ipynb)."
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "29fc3366-1b42-446f-a078-f5443918f246",
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"\n",
"from numba import njit, uint64, float64\n",
"from numba.typed import Dict\n",
"\n",
"from hftbacktest import BUY, SELL, GTX, LIMIT\n",
"\n",
"@njit\n",
"def mm_strategy(hbt, recorder):\n",
" asset_no = 0\n",
" tick_size = hbt.depth(asset_no).tick_size\n",
" order_qty = 1\n",
" grid_num = 10\n",
" max_position = grid_num * order_qty\n",
" # Our half spread is just half a tick size,\n",
" # but it's considered a round-off error, so we use 0.49, which is slightly less than 0.5.\n",
" # If you set a lower value, the order will tend to stay to the best bid and offer, even when book pressure increases.\n",
" # You can think of it as a threshold for backing off based on book pressure.\n",
" half_spread = tick_size * 0.49\n",
" grid_interval = tick_size\n",
" skew_adj = 1.0\n",
" \n",
" # Running interval in nanoseconds.\n",
" while hbt.elapse(100_000_000) == 0: \n",
" # Clears cancelled, filled or expired orders. \n",
" hbt.clear_inactive_orders(asset_no)\n",
"\n",
" depth = hbt.depth(asset_no)\n",
" position = hbt.position(asset_no)\n",
" orders = hbt.orders(asset_no)\n",
" last_trades = hbt.last_trades(asset_no)\n",
"\n",
" best_bid = depth.best_bid\n",
" best_ask = depth.best_ask\n",
"\n",
" best_bid_qty = depth.bid_depth[depth.best_bid_tick]\n",
" best_ask_qty = depth.ask_depth[depth.best_ask_tick]\n",
"\n",
" # Market microstructure signals in https://blog.headlandstech.com/2017/08/\n",
" book_pressure = (best_bid * best_ask_qty + best_ask * best_bid_qty) / (best_bid_qty + best_ask_qty)\n",
" \n",
" skew = half_spread / grid_num * skew_adj\n",
"\n",
" normalized_position = position / order_qty\n",
"\n",
" # The personalized price that considers skewing based on inventory risk is introduced, \n",
" # which is described in the well-known Stokov-Avalleneda market-making paper.\n",
" # https://math.nyu.edu/~avellane/HighFrequencyTrading.pdf\n",
" reservation_price = book_pressure - skew * normalized_position\n",
"\n",
" # Since our price is skewed, it may cross the spread. To ensure market making and avoid crossing the spread, \n",
" # limit the price to the best bid and best ask.\n",
" bid_price = np.minimum(reservation_price - half_spread, best_bid)\n",
" ask_price = np.maximum(reservation_price + half_spread, best_ask)\n",
"\n",
" # Aligns the prices to the grid.\n",
" bid_price = np.floor(bid_price / grid_interval) * grid_interval\n",
" ask_price = np.ceil(ask_price / grid_interval) * grid_interval\n",
" \n",
" #--------------------------------------------------------\n",
" # Updates quotes.\n",
" \n",
" # Creates a new grid for buy orders.\n",
" new_bid_orders = Dict.empty(np.uint64, np.float64)\n",
" if position < max_position and np.isfinite(bid_price):\n",
" for i in range(grid_num):\n",
" bid_price_tick = round(bid_price / tick_size)\n",
" \n",
" # order price in tick is used as order id.\n",
" new_bid_orders[uint64(bid_price_tick)] = bid_price\n",
" \n",
" bid_price -= grid_interval\n",
"\n",
" # Creates a new grid for sell orders.\n",
" new_ask_orders = Dict.empty(np.uint64, np.float64)\n",
" if position > -max_position and np.isfinite(ask_price):\n",
" for i in range(grid_num):\n",
" ask_price_tick = round(ask_price / tick_size)\n",
" \n",
" # order price in tick is used as order id.\n",
" new_ask_orders[uint64(ask_price_tick)] = ask_price\n",
"\n",
" ask_price += grid_interval\n",
" \n",
" order_values = orders.values();\n",
" while order_values.has_next():\n",
" order = order_values.get()\n",
" # Cancels if a working order is not in the new grid.\n",
" if order.cancellable:\n",
" if (\n",
" (order.side == BUY and order.order_id not in new_bid_orders)\n",
" or (order.side == SELL and order.order_id not in new_ask_orders)\n",
" ):\n",
" hbt.cancel(asset_no, order.order_id, False)\n",
" \n",
" for order_id, order_price in new_bid_orders.items():\n",
" # Posts a new buy order if there is no working order at the price on the new grid.\n",
" if order_id not in orders:\n",
" hbt.submit_buy_order(asset_no, order_id, order_price, order_qty, GTX, LIMIT, False)\n",
" \n",
" for order_id, order_price in new_ask_orders.items():\n",
" # Posts a new sell order if there is no working order at the price on the new grid.\n",
" if order_id not in orders:\n",
" hbt.submit_sell_order(asset_no, order_id, order_price, order_qty, GTX, LIMIT, False)\n",
" \n",
" # Records the current state for stat calculation.\n",
" recorder.record(hbt)\n",
" return True"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "74c5ff4d-7817-4dcc-86c6-0e84371319ae",
"metadata": {},
"outputs": [],
"source": [
"from hftbacktest import BacktestAsset, ROIVectorMarketDepthBacktest, Recorder\n",
"\n",
"asset = (\n",
" BacktestAsset()\n",
" .data([\n",
" f'data/CRVUSDT_{date}.npz' for date in range(20240701, 20240732)\n",
" ] + [\n",
" f'data/CRVUSDT_{date}.npz' for date in range(20240801, 20240832)\n",
" ])\n",
" .linear_asset(1.0) \n",
" .intp_order_latency([\n",
" f'latency/amp_feed_latency_{date}.npz' for date in range(20240701, 20240732)\n",
" ] + [\n",
" f'latency/amp_feed_latency_{date}.npz' for date in range(20240801, 20240832)\n",
" ])\n",
" .power_prob_queue_model(3.0) \n",
" .no_partial_fill_exchange()\n",
" .trading_value_fee_model(-0.00005, 0.0007)\n",
" .tick_size(0.001)\n",
" .lot_size(0.1)\n",
" .roi_lb(0.0) \n",
" .roi_ub(2.0)\n",
" .last_trades_capacity(1000)\n",
")\n",
"hbt = ROIVectorMarketDepthBacktest([asset])\n",
"\n",
"recorder = Recorder(1, 100_000_000)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "a711a16b-8ba8-4c86-884a-167ca93ac1be",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 8min 14s, sys: 8.57 s, total: 8min 23s\n",
"Wall time: 6min 49s\n"
]
}
],
"source": [
"%%time\n",
"mm_strategy(hbt, recorder.recorder)\n",
"\n",
"_ = hbt.close()"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "820242e5-a09d-42f8-ad69-d035e7020b5e",
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"stats.plot()"
]
},
{
"cell_type": "markdown",
"id": "8d9f3429-e82d-48d1-a51c-c88338ac372b",
"metadata": {},
"source": [
"There is not much difference, as the last trade quantity is relatively small compared to the best bid and offer quantities.\n",
"\n",
"\n",
"\n",
"The following example demonstrates a variant of trade impulse using aggregated trade quantities."
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "4f8e6402-ea71-4df2-8ed3-8418c0ee2309",
"metadata": {},
"outputs": [],
"source": [
"@njit\n",
"def mm_strategy(hbt, recorder):\n",
" asset_no = 0\n",
" tick_size = hbt.depth(asset_no).tick_size\n",
" order_qty = 1\n",
" grid_num = 10\n",
" max_position = grid_num * order_qty\n",
" # Our half spread is just half a tick size,\n",
" # but it's considered a round-off error, so we use 0.49, which is slightly less than 0.5.\n",
" half_spread = tick_size * 0.49\n",
" grid_interval = tick_size\n",
" skew_adj = 1.0\n",
" trade_impulse_adj = 1.0\n",
"\n",
" sum_bbo_qty = np.empty(50_000_000, float64)\n",
" i = 0\n",
" \n",
" # Running interval in nanoseconds.\n",
" while hbt.elapse(100_000_000) == 0: \n",
" # Clears cancelled, filled or expired orders. \n",
" hbt.clear_inactive_orders(asset_no)\n",
"\n",
" depth = hbt.depth(asset_no)\n",
" position = hbt.position(asset_no)\n",
" orders = hbt.orders(asset_no)\n",
" last_trades = hbt.last_trades(asset_no)\n",
"\n",
" best_bid = depth.best_bid\n",
" best_ask = depth.best_ask\n",
"\n",
" best_bid_qty = depth.bid_depth[depth.best_bid_tick]\n",
" best_ask_qty = depth.ask_depth[depth.best_ask_tick]\n",
"\n",
" # Market microstructure signals in https://blog.headlandstech.com/2017/08/\n",
" book_pressure = (best_bid * best_ask_qty + best_ask * best_bid_qty) / (best_bid_qty + best_ask_qty)\n",
" \n",
" # Computes the trading impulse\n",
" last_qty = 0\n",
" for last_trade in last_trades:\n",
" if last_trade.ev & BUY_EVENT == BUY_EVENT:\n",
" last_qty += last_trade.qty\n",
" else:\n",
" last_qty -= -last_trade.qty\n",
"\n",
" hbt.clear_last_trades(asset_no)\n",
" \n",
" sum_bbo_qty[i] = best_bid_qty + best_ask_qty\n",
" i += 1\n",
"\n",
" # Uses the last 1-minute average BBO quantity as the denominator.\n",
" trade_impulse = (tick_size / 2.0) * last_qty / np.mean(sum_bbo_qty[max(0, i - 600):i])\n",
" \n",
" fair_price = book_pressure + trade_impulse * trade_impulse_adj\n",
" \n",
" skew = half_spread / grid_num * skew_adj\n",
"\n",
" normalized_position = position / order_qty\n",
"\n",
" # The personalized price that considers skewing based on inventory risk is introduced, \n",
" # which is described in the well-known Stokov-Avalleneda market-making paper.\n",
" # https://math.nyu.edu/~avellane/HighFrequencyTrading.pdf\n",
" reservation_price = fair_price - skew * normalized_position\n",
"\n",
" # Since our price is skewed, it may cross the spread. To ensure market making and avoid crossing the spread, \n",
" # limit the price to the best bid and best ask.\n",
" bid_price = np.minimum(reservation_price - half_spread, best_bid)\n",
" ask_price = np.maximum(reservation_price + half_spread, best_ask)\n",
"\n",
" # Aligns the prices to the grid.\n",
" bid_price = np.floor(bid_price / grid_interval) * grid_interval\n",
" ask_price = np.ceil(ask_price / grid_interval) * grid_interval\n",
" \n",
" #--------------------------------------------------------\n",
" # Updates quotes.\n",
" \n",
" # Creates a new grid for buy orders.\n",
" new_bid_orders = Dict.empty(np.uint64, np.float64)\n",
" if position < max_position and np.isfinite(bid_price):\n",
" for i in range(grid_num):\n",
" bid_price_tick = round(bid_price / tick_size)\n",
" \n",
" # order price in tick is used as order id.\n",
" new_bid_orders[uint64(bid_price_tick)] = bid_price\n",
" \n",
" bid_price -= grid_interval\n",
"\n",
" # Creates a new grid for sell orders.\n",
" new_ask_orders = Dict.empty(np.uint64, np.float64)\n",
" if position > -max_position and np.isfinite(ask_price):\n",
" for i in range(grid_num):\n",
" ask_price_tick = round(ask_price / tick_size)\n",
" \n",
" # order price in tick is used as order id.\n",
" new_ask_orders[uint64(ask_price_tick)] = ask_price\n",
"\n",
" ask_price += grid_interval\n",
" \n",
" order_values = orders.values();\n",
" while order_values.has_next():\n",
" order = order_values.get()\n",
" # Cancels if a working order is not in the new grid.\n",
" if order.cancellable:\n",
" if (\n",
" (order.side == BUY and order.order_id not in new_bid_orders)\n",
" or (order.side == SELL and order.order_id not in new_ask_orders)\n",
" ):\n",
" hbt.cancel(asset_no, order.order_id, False)\n",
" \n",
" for order_id, order_price in new_bid_orders.items():\n",
" # Posts a new buy order if there is no working order at the price on the new grid.\n",
" if order_id not in orders:\n",
" hbt.submit_buy_order(asset_no, order_id, order_price, order_qty, GTX, LIMIT, False)\n",
" \n",
" for order_id, order_price in new_ask_orders.items():\n",
" # Posts a new sell order if there is no working order at the price on the new grid.\n",
" if order_id not in orders:\n",
" hbt.submit_sell_order(asset_no, order_id, order_price, order_qty, GTX, LIMIT, False)\n",
" \n",
" # Records the current state for stat calculation.\n",
" recorder.record(hbt)\n",
" return True"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "3c3f57d6-5d76-40aa-84e8-b2abc544036b",
"metadata": {},
"outputs": [],
"source": [
"hbt = ROIVectorMarketDepthBacktest([asset])\n",
"\n",
"recorder = Recorder(1, 100_000_000)"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "127da1a5-a1ef-4239-83b6-e62f1f201bfe",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 8min 13s, sys: 7.99 s, total: 8min 21s\n",
"Wall time: 6min 48s\n"
]
}
],
"source": [
"%%time\n",
"mm_strategy(hbt, recorder.recorder)\n",
"\n",
"_ = hbt.close()"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "1031d893-2870-4ebf-bbcd-b357e15791ab",
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"stats.plot()"
]
},
{
"cell_type": "markdown",
"id": "c15cf0c8-c6ce-4b18-bfdb-994a9802b0e3",
"metadata": {},
"source": [
"You can also adjust `trade_impulse_adj` to modify the impact of the trade impulse. Alternatively, you can explore other ways to compute the trade impulse, such as `(best_bid * best_ask_qty + best_ask * best_bid_qty + last_px * last_qty) / (best_bid_qty + best_ask_qty + last_qty)`, VWAP, etc."
]
},
{
"cell_type": "markdown",
"id": "21001a6c-8f10-45bb-9287-faf49fca8146",
"metadata": {},
"source": [
"## Pure Queue-Based Model\n",
"\n",
"One possible reason for this strategy's profitability is the limited price movement due to the large tick size. For instance, CRVUSDT has a tick size of 38 basis points (0.001 / 0.26 * 10,000), which is comparatively very larger than BTCUSDT, where the tick size is approximately 0.018 basis points (0.1 / 54,000 * 10,000).\n",
"\n",
"This also highlights the importance of queue position modeling in fill simulations for assets with large tick sizes.\n",
"\n",
"In the CRVUSDT charts shown above, observing the trading activities, you can see that most trades occur at the best bid and ask prices, with little change in the overall price level.\n",
"\n",
"This suggests an opportunity to adjust the microstructure signal into a purely queue-based signal. For example, if there is sufficient quantity to maintain the price level, preventing it from moving adversely, we can choose to maintain our quote. Let’s explore how this can be implemented in a simplified form."
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "15533bfe-04b1-4f78-b20f-2c43ff56b595",
"metadata": {},
"outputs": [],
"source": [
"@njit\n",
"def mm_strategy(hbt, recorder):\n",
" asset_no = 0\n",
" tick_size = hbt.depth(asset_no).tick_size\n",
" order_qty = 1\n",
" grid_num = 10\n",
" max_position = grid_num * order_qty\n",
" # Our half spread is just half a tick size,\n",
" # but it's considered a round-off error, so we use 0.49, which is slightly less than 0.5.\n",
" half_spread = tick_size * 0.49\n",
" grid_interval = tick_size\n",
" skew_adj = 1.0\n",
" qty_threshold = 250_000\n",
" \n",
" # Running interval in nanoseconds.\n",
" while hbt.elapse(100_000_000) == 0: \n",
" # Clears cancelled, filled or expired orders. \n",
" hbt.clear_inactive_orders(asset_no)\n",
"\n",
" depth = hbt.depth(asset_no)\n",
" position = hbt.position(asset_no)\n",
" orders = hbt.orders(asset_no)\n",
" last_trades = hbt.last_trades(asset_no)\n",
"\n",
" best_bid = depth.best_bid\n",
" best_ask = depth.best_ask\n",
"\n",
" best_bid_qty = depth.bid_depth[depth.best_bid_tick]\n",
" best_ask_qty = depth.ask_depth[depth.best_ask_tick]\n",
" \n",
" skew = half_spread / grid_num * skew_adj\n",
"\n",
" normalized_position = position / order_qty\n",
"\n",
" skew_val = skew * normalized_position\n",
" if best_bid_qty < qty_threshold and skew_val > 0:\n",
" bid_price = best_bid - tick_size\n",
" else:\n",
" bid_price = best_bid\n",
" \n",
" if best_ask_qty < qty_threshold and skew_val < 0:\n",
" ask_price = best_ask + tick_size\n",
" else:\n",
" ask_price = best_ask\n",
" \n",
" # Aligns the prices to the grid.\n",
" bid_price = np.floor(bid_price / grid_interval) * grid_interval\n",
" ask_price = np.ceil(ask_price / grid_interval) * grid_interval\n",
" \n",
" #--------------------------------------------------------\n",
" # Updates quotes.\n",
" \n",
" # Creates a new grid for buy orders.\n",
" new_bid_orders = Dict.empty(np.uint64, np.float64)\n",
" if position < max_position and np.isfinite(bid_price):\n",
" for i in range(grid_num):\n",
" bid_price_tick = round(bid_price / tick_size)\n",
" \n",
" # order price in tick is used as order id.\n",
" new_bid_orders[uint64(bid_price_tick)] = bid_price\n",
" \n",
" bid_price -= grid_interval\n",
"\n",
" # Creates a new grid for sell orders.\n",
" new_ask_orders = Dict.empty(np.uint64, np.float64)\n",
" if position > -max_position and np.isfinite(ask_price):\n",
" for i in range(grid_num):\n",
" ask_price_tick = round(ask_price / tick_size)\n",
" \n",
" # order price in tick is used as order id.\n",
" new_ask_orders[uint64(ask_price_tick)] = ask_price\n",
"\n",
" ask_price += grid_interval\n",
" \n",
" order_values = orders.values();\n",
" while order_values.has_next():\n",
" order = order_values.get()\n",
" # Cancels if a working order is not in the new grid.\n",
" if order.cancellable:\n",
" if (\n",
" (order.side == BUY and order.order_id not in new_bid_orders)\n",
" or (order.side == SELL and order.order_id not in new_ask_orders)\n",
" ):\n",
" hbt.cancel(asset_no, order.order_id, False)\n",
" \n",
" for order_id, order_price in new_bid_orders.items():\n",
" # Posts a new buy order if there is no working order at the price on the new grid.\n",
" if order_id not in orders:\n",
" hbt.submit_buy_order(asset_no, order_id, order_price, order_qty, GTX, LIMIT, False)\n",
" \n",
" for order_id, order_price in new_ask_orders.items():\n",
" # Posts a new sell order if there is no working order at the price on the new grid.\n",
" if order_id not in orders:\n",
" hbt.submit_sell_order(asset_no, order_id, order_price, order_qty, GTX, LIMIT, False)\n",
" \n",
" # Records the current state for stat calculation.\n",
" recorder.record(hbt)\n",
" return True"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "8fa24ec0-b073-4d78-a178-b58812414eee",
"metadata": {},
"outputs": [],
"source": [
"hbt = ROIVectorMarketDepthBacktest([asset])\n",
"\n",
"recorder = Recorder(1, 100_000_000)"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "83a7d045-0b59-4a2e-8f55-92dd18abb697",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 8min 16s, sys: 8.52 s, total: 8min 24s\n",
"Wall time: 6min 51s\n"
]
}
],
"source": [
"%%time\n",
"mm_strategy(hbt, recorder.recorder)\n",
"\n",
"_ = hbt.close()"
]
},
{
"cell_type": "code",
"execution_count": 19,
"id": "9369a91f-7a6a-44ac-bb89-d4c4ddd5f48e",
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"shape: (1, 11)
start
end
SR
Sortino
Return
MaxDrawdown
DailyNumberOfTrades
DailyTradingValue
ReturnOverMDD
ReturnOverTrade
MaxPositionValue
datetime[μs]
datetime[μs]
f64
f64
f64
f64
f64
f64
f64
f64
f64
2024-07-01 00:00:00
2024-08-31 23:59:50
13.199337
18.042325
3.95075
0.18009
1840.60021
509.758968
21.937611
0.000125
3.6905
"
],
"text/plain": [
"shape: (1, 11)\n",
"┌───────────┬───────────┬───────────┬───────────┬───┬───────────┬───────────┬───────────┬──────────┐\n",
"│ start ┆ end ┆ SR ┆ Sortino ┆ … ┆ DailyTrad ┆ ReturnOve ┆ ReturnOve ┆ MaxPosit │\n",
"│ --- ┆ --- ┆ --- ┆ --- ┆ ┆ ingValue ┆ rMDD ┆ rTrade ┆ ionValue │\n",
"│ datetime[ ┆ datetime[ ┆ f64 ┆ f64 ┆ ┆ --- ┆ --- ┆ --- ┆ --- │\n",
"│ μs] ┆ μs] ┆ ┆ ┆ ┆ f64 ┆ f64 ┆ f64 ┆ f64 │\n",
"╞═══════════╪═══════════╪═══════════╪═══════════╪═══╪═══════════╪═══════════╪═══════════╪══════════╡\n",
"│ 2024-07-0 ┆ 2024-08-3 ┆ 13.199337 ┆ 18.042325 ┆ … ┆ 509.75896 ┆ 21.937611 ┆ 0.000125 ┆ 3.6905 │\n",
"│ 1 ┆ 1 ┆ ┆ ┆ ┆ 8 ┆ ┆ ┆ │\n",
"│ 00:00:00 ┆ 23:59:50 ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n",
"└───────────┴───────────┴───────────┴───────────┴───┴───────────┴───────────┴───────────┴──────────┘"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"stats = LinearAssetRecord(recorder.get(0)).stats()\n",
"stats.summary()"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "9ff6be44-afb7-4894-9a0b-9cda848f2e06",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAA5EAAAH5CAYAAAAY6rqhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3xT9foH8E9W0733bmlL6YQWEESW7KGiqOh1gIJef44rel0oKjgQrwpeF+pVQb2KE3EhCl5ZCo7SslpWaenee2Sf3x8hpznJyWzSpO3zfr14kZxzcvLNSZqc53y/3+cRMAzDgBBCCCGEEEIIsYLQ1Q0ghBBCCCGEEDJ4UBBJCCGEEEIIIcRqFEQSQgghhBBCCLEaBZGEEEIIIYQQQqxGQSQhhBBCCCGEEKtREEkIIYQQQgghxGoURBJCCCGEEEIIsZrY1Q1wNyqVCoWFhYiIiIBQSDE2IYQQQgghw5VGo0F9fT3GjBkDsZhCJx06EgYKCwsxfvx4VzeDEEIIIYQQ4ib++OMPjBs3ztXNcBsURBqIiIgAoP2gREVFubQtKpUKP//8M2bMmEFXPmxEx65/6Pj1Dx2/wY/ew/6h42c/Onb9Q8dv8HO397C2thbjx49nYwSi5fp3xs3ohrBGRUUhNjbWpW1RKpUIDQ1FTEwMJBKJS9sy2NCx6x86fv1Dx2/wo/ewf+j42Y+OXf/Q8Rv83PU9pGluXHQ0CCGEEEIIIYRYjYJIQgghhBBCCCFWG9JB5HPPPQeBQICVK1e6uimEEEIIIYQQMiQM2TmRf/75J95++23k5OQ4fN8ajQYKhcLh+zWkVCohFoshk8mgVqud/nxDyWA4dhKJBCKRyNXNIIQQQsggNVDnpANpoM/h6HzMPkMyiOzq6sINN9yA//znP3jmmWfMbiuXyyGXy9n7nZ2dALSZoZRKpdH2CoUClZWV0Gg0jm00D4ZhEBkZiYqKCggEAqc/31AyWI6dv78/wsPD3a6Nus8+398AsYyO3+BH72H/0PGzHx27/hlOx28gz0kHkivO4cydj6lUqgFpw2AjYBiGcXUjHG3p0qUIDg7Gxo0bMW3aNIwePRovv/wy77Zr1qzB2rVrjZa/8847CA0NNVoeHByMoKAghIWFud2JPxk8GIaBQqFAU1MTWltb2YsXhBBCCCHWoHPS/rPmfKypqQkrVqxAZWWlyys3uJMh1xP5ySef4PDhw/jzzz+t2n7VqlW4//772fvV1dXIyMjAjBkzEBMTw9lWpVKhrKwM0dHR8Pf3d2i7+TAMg87OTvj5+dGXg40Gy7Hz9PSEVCrFxRdf7FZDKZRKJXbt2oVZs2a5VXrtwYKO3+BH72H/0PGzHx27/nHF8VOpVGAYZkDfr4E+Jx0oKg0DtVqDjq5uBPn7QiwamPQt5s7HqqurB6QNg82QCiIrKytx77334qeffoKnp6dVj5FKpZBKpez9jo4OAIBYLDb6MlCr1RAIBJBKpQNSK0Y3PEEgEFBtGhsNlmPn6+uLpqYmAHDLkwWJROKW7Ros6PgNfvQe9g8dP/vRseufgTx+R48eBQCMGTNmwM45Bvqc1Nk0DIPimg5o9AZIKgQKxAV7D8jzmzsfE4uHVLjkMEPqqBQUFKChoQH5+fnsMrVajX379uG1116DXC53SG+PO/dskcGFPkuEEELI4KU/K6y7uxt+fn4D+vyD/TyCYRhUt/aipcc4OZBENHCvbbAfR1cYUkHkjBkzcOzYMc6yW265Benp6Xj44YfdarggIYQQQggZ3PQT+FRWVkKtViMoKMjlc+eOVrUBAFLDfeHl4V6n+yq1BsW1HSbXxwd7Qy3rQZCf1OQ2xPXc61PVT35+fsjKyuIs8/HxQUhIiNFy4lhbtmzBypUr0dbW5uqmEEIIIYQMiIaGBvZ2b28vAKC+vh5RUVED0nnBMAwbMIb6StHUJeesP9PQhZzYQKe3wxKZUo3GTjnaepRgwJ/T08dDjKRQHwAMOoZW1ZIhafAPoiYWLVu2DAKBwOjf3LlzHfYcS5YswenTp9n7a9aswejRox22f0IIIYQQd6JWq1FfX8+7Tje/zhl+OFaLGS/tQVVrL07X92UTNQwg3UV5UzdO13eitUfBG0DGBHohJzYQI8J9IRTyDyudNm0aVq5c6eSWElsMqZ5IPnv27HF1E9zC3LlzsXnzZs4y/YRC/eXl5QUvLy+H7Y8QQgghxJ2Zy9rpyDqVDMOgtLEbag2DxZt+Q5dchRg/63s5exQq1LTJoFJrkBbpB6ET5//1KFSoaOmBQmW6duUT99+Frz//GIA2aU1cXByuuuoqrF27Fj4+PryP2bZtGyWacjPUEzlMSKVSREZGcv4FBQUBAM6cOYMpU6bA09MTGRkZ2LVrFwQCAbZv3w5AG4gLBALOUNWioiIIBAKUl5cD0A5nDQwMZG+vXbsWR44cYXs9t2zZgltvvRULFy7ktEulUiEyMhLvvfeesw8BIYQQQojDNDY2mlwnlxv3CspVaizb/AcSH/me/adSc4Ot1m4FJ1nPqbpOJK3agZkb9mLOy/vQJTdd+D7C3xOZ0QFIj/RHcpgvu/xsQxd6FCoo1BqUNXaz+9doGE42VHs1dspxtKoNR6vacLahy2QAmRjig+yYAAR6SzB37lzU1tbi3LlzeOaZZ/DGG2/ggQceMHqMLhgPDg4e8KRFxLwh3xPpTAzDoFepdtr+NRoNehVqiBUqo/TNXhKRQzJJaTQaXHXVVQgNDcWhQ4fQ0dHR7+ECS5YswfHjx7Fz507s3r0bABAQEIC0tDRMmTIFtbW1iIqKAgDs2LEDXV1duPbaa/v7UgghhBBCHKKmrRf7zzQiNy4Qc1/eDwD48v8mIj8hGADQ1dVl9vH6F941Gga/l7Xg+v8cMtou5bEfeB+/cUku7vv0CO+6AC8JvrpzAppqq5Ec6c+WtdOWN2MgFgJCgYAtd6avU6bAkUruhENbk+/0KtUoa+yG6sL+LZUYiQ/2RoCXhHPequvcAIC//e1v+OWXX7B9+3ZERERg+/btWLFiBTZs2IDy8nKo1WpMnz4do0ePxssvvwxAG6Q//vjj2Lp1KxoaGhAfH49HHnkEy5cvBwAUFxfjgQcewL59++Dj44PZs2dj48aNCA0Ntfp1EvMoiOyHXqUaGU/86JLnLn5qDrxt+IP/7rvv4Ovry1n28MMP46KLLkJJSQnKy8vZTGLr1q3DvHnz7G6bl5cXfH19IRaL2S8IALj44osxcuRIfPjhh3jooYcAAJs3b8Y111xj1DZCCCGEkIHQKVPi55IGPL/zJGrbZSa3W7zpIEqemgsvD5HViQT/tfMk3thTanObTAWQ/p5iHHlyNmQyGZr1+hI0Gg0KCws521a0dEOuND2sVOcktIGpl4cIvlIxJ9hTqTWQqzQQiwSoaO7hfXx6Vg4bSCaG+EAkFKC0sQvhfp6IDLCubruXlxfb63j27Fls374dn3/+uckhrDfffDMOHjyIV155Bbm5uSgrK2PnodbW1mLq1Km47bbbsGHDBvT29uLhhx/Gtddei//9739WtYdYRkHkMDF9+nRs2rSJsyw4OBgffvgh4uPjOamoJ06c6LR2rFixAm+//TYeeughNDQ04Pvvv8fPP//stOcjhBBCCOFTcL4FizcdtOkxo57YiW13TADTzJ9QR+dEoxKLH/neaPn7t45HeqQfLlpn/bnPh8vHIy7IG8G+HvD3tH5eYHywDzt0taVbgZZu0ylP23uVaO9Vwt9Lgm65CmqN9cNcQ32liAny5gSftmSE/eOPP/Dxxx9jxowZAACFQoE333wTycnJvL2cp0+fxmeffYZdu3Zh5syZAIDk5GR2/aZNm5CXl4d169axy9577z3ExcXh9OnTSEtLs7ptxDQKIvvBSyJC8VNznLZ/jUaDzo5O+Pn78Q5ntYWPjw9SUlKMljM8Y+ENh8nqnlt/W3snjN9888145JFHcPDgQRw8eBCJiYmYPHmyXfsihBBCCLGVUq1B5pM/mk3+YgqjVmHBmv9izWUZGJsYbLRerlKjoUOGR78pg9ifO3Tyj0dnINxf2zP39V2TUN7cjXs/KWLXl69fgMQLgee/rxuNK0bHWN0uoVCIMWPGmN2mW65CaaP5YbjWSgn3hVQsgkgosDiclY9uhJxKpYJSqcQVV1yBV199FW+88QYSEhLMDjstKiqCSCTC1KlTedcXFBTgl19+4R3lVlpaSkGkg1AQ2Q8CgcCmIaW20mg0UHmI4O0htusP1BoZGRmoqKhATU0NoqOjAQAHD3KvyoWFhQHQDg/QJeMpKioyu18PDw+o1cbzRUNCQrBo0SJs3rwZBw8exC233OKAV0EIIYQQYt7Jug52fqMhD5EQC3Oj8OLVuSip68DT3xXj0LkWbF42DqOi/DHhOW3PoUbeDQBY820xvrvnEgBAbGwc3t/1FzbuPsPuT+QdwN4uXTcfIoPSFblxgciNC0SPQo1V246xnRLl6xfY/fosnSv6eXkgJy4ILd0K+ErFEAkFkCnVqO+Qo0fBn7AnzE+KYB8PnG/uQWygF7yljjnv1Y2Qk0gkiI6O5gxbNZWhVcdSNQCNRoPLLrsMzz//vNE6XU4O0n8URA4TcrkcdXV1nGVisRgzZ87EyJEjcfPNN+Oll15CR0cHHnvsMc52KSkpiIuLw5o1a/DMM8/gzJkzeOmll8w+X2JiIsrKylBUVITY2Fj4+fmxJUVWrFiBhQsXQq1WY+nSpY59oYQQQgghBjQahjeAPLRqBsL8pJwgLzM6AJ/czp3a896ysbh1y19gVH0jsRa+egAA4BExAop67rxHjawLj143GbdPGWG2XdePj8f14+Ntfj32EgoECPXtK/EmEQnh5ylBp0yJsiZtgJwa7gdPiZAzMi0twrGZUU2NkLNGdnY2NBoN9u7dyw5n1ZeXl4cvv/wSiYmJEIsp1HEWKvExTOzcuRNRUVGcf5dccgmEQiG++uoryOVyjB8/HitWrMCzzz7LeaxEIsHWrVtx8uRJ5Obm4vnnn8czzzxj9vkWL16MuXPnYvr06QgLC8PWrVvZdTNnzkRUVBTmzJnD9n4SQgghhDhL8qM7OPc/XD4e5esXIDLA06iXkM+l6RE48PB0zEw0rrGtH2x5irWn1rNGhloMIN2Jn6cEObGByIkNhJeHYyoAOEtiYiKWLl2KW2+9Fdu3b0dZWRn27NmDzz77DABw1113oaWlBddffz3++OMPnDt3Dj/99BNuvfVW3lFyxD4Ung8DW7ZswZYtW0yuT0tLw/79/MM7dCZNmoSjR49ylunPkVy2bBmWLVvG3pdKpfjiiy9499Xb24u2tjY2DTMhhBBCiLMk8iS4mZwaZvN+YoO8EeTjwVkmFGuDSo+IZHy6YiwkHTX2NZLYZNOmTXj00Udx5513orm5GfHx8Xj00UcBANHR0fj111/x8MMPY86cOZDL5UhISMDcuXOdNj1sOKIgkgwYjUaDuro6vPTSSwgICMDll1/u6iYRQgghZAj74GA55/6L1+Ri0Wj7R0H9dII7NWjx5Gy8snQSe7+ggIJIS8x1bKxZswZPPPEEOjo6OMv37NnDue/p6YkNGzZgw4YNvPtJTU3Ftm3b+ttUYgaF42TAVFRUICYmBp999hnee+89GqdOCCGEEIc71wF8cbgaiY98jye+PsEu333/FFydHwuxyP7T38yYvoQ5G6/NxcYbJ/SrrWRoeuONN5CUlARPT0/k5+ebHfF34MABTJo0CSEhIfDy8kJ6ejo2btzI2WbLli0QCARG/2Qy03VNnY3O4gkvvtIf/ZWYmOiU/RJCCCGEdMtVmP/vAzjfIgZOnDBanxLe/+Qw988ZBU/xKeTEBiA9OhAikemSaxUVFYiPH7ikOcQ9fPrpp1i5ciXeeOMNTJo0CW+99RbmzZuH4uJi3s+Dj48P7r77buTk5MDHxwcHDhzA3//+d/j4+OD2229nt/P398epU6c4j/X09HT66zGFgkhCCCGEEOJSDMOgo1eF3Kd+AgD8uHIKRkZaF/St/+Ek3txbanabY2tm97uNAJAUF4N7Z2oviPOVi0hPT8fJkycBAI2NjRREDiGdnZ2cYbZSqZStPKBvw4YNWL58OVasWAEAePnll/Hjjz9i06ZNeO6554y2HzNmDKfGZ2JiIrZt24b9+/dzgkiBQIDIyEhHvqR+oeGshBBCCCHEZaa+8AuSVu1gA0gAmPPyPgCATKnGjyfqoNaYHslkKoD84o6JKF+/AOXrF8DPU8K7ja30s5aGh4db3F6l4q+/SAafjIwMBAQEsP/4AkKFQoGCggLMns29aDF79mz89ttvVj1PYWEhfvvtN0ydOpWzvKurCwkJCYiNjcXChQtRWFho/4txAOqJJIQQQgghA66tR4HRT+0yuV4/q+q1Y2Pxr6tzzW6j86/xKlx52XxOAXtH0U3LCQ4OtqoMRkdHB4KDgx3eDsP2kP7RaDQWtykuLkZMTAx7n68XsqmpCWq1GhEREZzlERERRvXaDcXGxqKxsREqlQpr1qxhezIBbQ/3li1bkJ2djY6ODvz73//GpEmTcOTIEaSmplpsuzNQEEkIIYQQQhzuwc+P4POCKvb+xiW5WJAdjaYuOS5e/z+b9lXe1GO0bOJzP3Puv7t0LKL8PHCmYJ99DbaBqQDS29vbqu36SyKRQCAQoLGxEWFhYW5d19FWGo0GCoUCMpnM6SU5GIaBQqFAY2MjhEIhPDw8TG7r5+cHf39/q/Zr+H4wDGPxPdq/fz+6urpw6NAhPPLII0hJScH1118PAJgwYQImTOhL4jRp0iTk5eXh1VdfxSuvvGJVmxyNgkhCCCGEEGJRbXsvJj6nDf4enZ+O26eM4N2uvVeJ3LU/GS2/79MjuO/TI7yP2ffgdLx74BzyEoJw7ydFRuuzYwM496e/uAe17TKoOhoBgRBfP7QQ+QnBUCqVOGPj67KFpZ4/gUCArKwsHD9+HABw7tw55OXlOTzIE4lEiI2NRVVVFcrLyx26b1djGAa9vb3w8vIasODY29sb8fHx/Q5aQ0NDIRKJjHodGxoajHonDSUlJQEAsrOzUV9fjzVr1rBBpCGhUIhx48bhzBlnftrNoyCSEEIIIYSYVNPWa9RzuG7HSSy/JBkiIfckv6ypG9Nf3GPT/v2kYsSHeGPtFVkAgOd/OImadm7pgo9/r8DjCzMAAKu3H0NZUzcYlRLqnnbtBk1lUET5OjzokMlkaGhoQGRkJKeXytzzGA6jra2tRXS0/bUpTfH19UVqaiqUSqXD9+1KSqUS+/btw5QpU5wyJNmQSCSCWCx2yGfHw8MD+fn52LVrF6688kp2+a5du3DFFVdYvR+GYSCXy82uLyoqQnZ2dr/a2x8URBKH2bJlC1auXIm2tjZXN8Uh3n77bTz99NOorq7Ghg0bsHLlSlc3iRBCCBlQf5a34Jo3D/Ku65QpEeitDaw0Gga3f1iA3SX1nG1OPzMPaat/MHpsWoQvPr19IoJ8jIcP7nlwOo5Vt+HNveewq1i7v16lmp3/yGjU0PR2QCDSBhjb77wYAHD8+HGHn1SfuFAqpLGxEfn5+VYlyjHszXJWEAloAyBzZUYGI5FIBJVKBU9PzwEJIh3t/vvvx0033YSxY8di4sSJePvtt1FRUYE77rgDALBq1SpUV1fjgw8+AAC8/vrriI+PR3p6OgBt3cgXX3wR99xzD7vPtWvXYsKECUhNTUVHRwdeeeUVFBUV4fXXXx/4F3gBBZHDwLJly/D+++8bLZ8zZw527tzpsOdZsmQJ5s+fz95fs2YNtm/fjqKiIoc9hy1yc3OxadMmTpus1dHRgbvvvhsbNmzA4sWLERAQYPlBhBBCyBChVGuQ+phx8PfWTfn4+4cFAIDRT+3CuXXzIRQKkPzoDqNtS9fNh0goQOHjszDn5X14ecloBHp7ICPa/LwyD7EQ+QnB+M/NwbyJc1QdjdDIugAAn/19AsQibdDm6CQzvb29Rst0z6FWqx36XGToWLJkCZqbm/HUU0+htrYWWVlZ2LFjBxISEgBoLypUVFSw22s0GqxatQplZWUQi8UYMWIE1q9fj7///e/sNm1tbbj99ttRV1eHgIAAjBkzBvv27cP48eMH/PXpUBA5TMydOxebN2/mLOPLKtUfXl5e8PLycug+7XX06FG0trZi+vTpdj2+oqICSqUSCxYs4K0DRQghhAxFlS09mPyvX4yW+3mKcWzNHKPld318GD8c75v/JRYKUPzUXHiI+3rjgnw88MdjM+1qT5C3BK093OGajEKbZOeFq3Pg7eG8U1nD4YQ9PT1OT/RChoY777wTd955J++6LVu2cO7fc889nF5HPhs3bsTGjRsd1TyHoL+EYUIqlSIyMpLzLygoiF1/5swZTJkyBZ6ensjIyMCuXbsgEAiwfft2AMCePXsgEAg4Q1WLioogEAjYCd1btmxBYGAge3vt2rU4cuQIBAIBBAIBtmzZgltvvRULFy7ktE2lUiEyMhLvvfeeUbsZhkFYWBi+/PJLdtno0aM5tZkOHjwIiUSCrq4udtk333yDSy+9lA2Uv/zyS2RmZkIqlSIxMREvvfSSyWOlS6EMAMnJyZzX+O233yI/Px+enp5ITk7G2rVrOUNb2tvbcfvttyM8PBz+/v649NJLceQIfxIBQgghxF1oNAwSH/meN4AEgMLHZ/Eu1w8gAeDMs/M4AWR/bVgyGozGuNfvu3suwago4x7Nzs5Ohz234Ry5kpISNDU1AYDZLJ58XJkAhRBnoJ7I/mAYQGmcctphNBrt/hUiwPDKl8QbcNDkcY1Gg6uuugqhoaE4dOgQOjo6+j3/b8mSJTh+/Dh27tyJ3bt3AwACAgKQlpaGKVOmoLa2lu3h27FjB7q6unDttdca7UcgEGDKlCnYs2cPFi9ejNbWVhQXF8PHxwfFxcXIyMjAnj17kJ+fD19fX/Zx3377LVtfp6CgANdeey3WrFmDJUuW4LfffsOdd96JkJAQLFu2jLftcXFxmDlzJv744w/ExcUhLCwMP/74I2688Ua88sormDx5MkpLS3H77bcDAJ588kkwDIMFCxYgODgYO3bsQEBAAN566y3MmDEDp0+fdmqdKEIIIcReczbuw6l64+Br250XIy8+yGj5xysuwt/e+d1oedlz8x2e2CYvUoowRS3UEl+0igLBMAyevizD5PaNjY0Oe26+4ay6C8e2vs6Ojg6T66wp/0CIu6Egsj+UPcA650yUBrTdxIGmVj5aA3j4WL2v7777jhNkAcDDDz+Mxx9/HLt370ZJSQnKy8sRGxsLAFi3bh3mzZtnV7sB7dBWX19fiMViREZGsssvvvhijBw5Eh9++CEeeughAMDmzZtxzTXXGLVPZ9q0aXj77bcBAPv27UNubi7i4+OxZ88eNoicNm0au311dTWOHDmC2bNnAwA2bNiAGTNm4PHHHwcApKWlobi4GC+88AJvEOnl5YWQkBAAQFhYGNv+Z599Fo888giWLl0KQNtL+fTTT+Ohhx7Ck08+iV9++QXHjh1DQ0MD2wP64osvYvv27fjiiy/YgJMQQghxB8U1HZj/yn6j5XsemIbEUNPnGBenhHLuv3L9GFye65zzobNnz+Ktm8YCAB7f34WyU8cxOn6Cye0dmalU1+vIx1KCnfT0dJw8edLiczQ3N6OiogIjRoywugYhIe6AhrMOE9OnT0dRURHn31133QVAOzwjPj6eDSABYOLEiU5ry4oVK9j5mQ0NDfj+++9x6623mtx+2rRpOHHiBJqamrB3715MmzYN06ZNw969e6FSqfDbb79h6tSp7PbffPMNJk2axA7XLSkpwaRJkzj7nDRpEs6cOWPTxPiCggI89dRT8PX1Zf/ddtttqK2tRU9PDwoKCtDV1YWQkBDONmVlZSgtLbXlEBFCCCFOVdbUzRtAAjAbQOqcfHou4oO98eyVWU4LIA1tvj4d/11hOoAEgO7uboc9n7kSC+YCTADw8fFhE6mYU15eDo1GQ8NdyaBDPZH9IfHW9gg6iUajQUdnJ/z9/Iwncku8bdqXj48PUlJSeNfxZTMzHFahe379be292nfzzTfjkUcewcGDB3Hw4EEkJiZi8uTJJrfPyspCSEgI9u7di7179+Kpp55CXFwcnn32Wfz555/o7e3FJZdcwm7/zTff4PLLL+e8PsPXY08GN41Gg7Vr1+Kqq64yWufp6QmNRoOoqCjs2bPHaL1urighhBDiatVtvUa1HIN9PHDjhATcNjnJqn14SkTY95B9yevsVVVVNaDP119BQUE4f/48e7+pqQnt7e1ISkqiBD1k0KMgsj8EApuGlNpMowEkau1zOPHLJiMjAxUVFaipqWHrGB08yK0JFRYWBkCblljXw2epdIeHhwdvT19ISAgWLVqEzZs34+DBg7jlllvM7kc3L/Lrr7/G8ePHMXnyZPj5+UGpVOLNN99EXl4e/Pz8AABdXV345Zdf8Oqrr3Je34EDBzj7/O2335CWlmZTbaW8vDycOnXKZDCel5eHuro6iMViJCYmWr1fQgghxJmam5tRXl6OUaNGoa5bg0tf2stZX75+gYta5hy1tbWubgIAbb3D+Ph4tpyDLqCsq6tDdHS00TmSSqWCWEyn5mRwoE/qMCGXy1FXx82gJhaLERoaipkzZ2LkyJG4+eab8dJLL6GjowOPPfYYZ9uUlBTExcVhzZo1eOaZZ3DmzBmzGU4BIDExEWVlZSgqKkJsbCz8/PzYuYIrVqzAwoULoVar2TmG5kybNg333XcfxowZw84ZmDJlCj766CPcf//97HY7d+5EamoqkpOT2Uns//znPzFu3Dg8/fTTWLJkCQ4ePIjXXnsNb7zxhuUDp+eJJ57AwoULERcXh2uuuQZCoRBHjx7FsWPH8Mwzz2DmzJmYOHEiFi1ahOeffx4jR45ETU0NduzYgUWLFmHs2LE2PR8hhBDiCLoM44VHj+GG7X3DMD+5fQImJIe4qFXWkUqlZoeV8nHkkFZTrB1hxJfvoba2FiKRyCjhnqPrXBLiTNSXPkzs3LkTUVFRnH+6IaBCoRBfffUV5HI5xo8fjxUrVuDZZ5/lPF4ikWDr1q04efIkcnNz8fzzz+OZZ54x+5yLFy/G3LlzMX36dISFhWHr1q3supkzZyIqKgpz5sxhez/NmT59OtRqNSeBztSpU6FWqznzIb/++mtcccUVnMfm5eXhs88+wyeffIKsrCw88cQTeOqpp3iT6pgzZ84cfPfdd9i1axfGjRuHCRMmYMOGDeycB4FAgB07dmDKlCm49dZbkZaWhuuuuw7l5eWIiIiw6bkIIYSQ/mjslCPxke/x+PbjWPjqASx89QCufvMQZxt3DyD7o78BmaXHW3PuAsBk/eyqqiocPXqUs8yWPA2EuBr1RA4DW7ZsMSpsaigtLQ379/NPsNeZNGmS0Ree/pfssmXLOIGZVCrFF198wbuv3t5etLW1Yfny5eYbf0FWVpbRF/rKlSs5pUjUajV27NiBH374wejxixcvxuLFi616LkBbi5LvB2TOnDmYM8e42LKOn58fXnnlFbzyyitWPxchhBBiK5Vagy65CoHe/PUKxz2rLa/14aHzvOsPrZrhtLYNNE9PTwgEAk5Jjvr6esTFxTntOW2tE2mNEydOID4+np1CRIg7oyCSDCiNRoO6ujq89NJLCAgI4CTA6a/m5mbcd999GDduHA0JIYQQMmS19yqRu/Yno+XPLMrCjRMSkPjI92Yf74x6js5izVDW0NBQCIVCdu4hALS0tPQriNQ/j5BIJEbJBJ2VGKeiogI9PT1WZXYlxJVoOCsZUBUVFYiJicFnn32G9957z6ETyMPDw7F69epB88NICCGE2Orx7cd5A0gAWL39uNkA8rH56Shfv2DQ/E6auiAcGhpqdN9wmUwmM3qcRqOx+jn0paenGy1z5jG0VD6EEHdAPZHEJGf05iUmJlIvISGEEGIjhUqDG945hD/LW61+zOTUUHy4/CIUFBRApdZALBo8fQdyuRwnTpzgXZeQkABfX182YZBAIIBAIEB+fj5+//133secPn0anZ2dCA4ORlKStowJwzAoLi6GSCQyChQbGhrY2xKJBF5eXpzhsoQMd4Pn24QQQgghZJhRqDR4/7dypK3+waYA8vnF2fhw+UXs/cEUQALachjmLjrr9wRac3G6s7MTgHaYq65HUiaTQSaTobu7GyqVirN9dXU1574u8ASAMWPGWH4BhAxx1BNJCCGEEOKm0lYbJ4vTObjqUtS2y+AnFSPAW4Lxz/7MrlsyLp73MU1NTUZDP92RLugzJSAggL2tX/M5PDycvV1YWAiNRmP0egsLC5Gfn49z586xy44cOQIAnJ5KHYFAAC8vL+Tn59v+QggZoiiItAMNxySOwjc/gxBCCAGA0sYuk+tOrJ0DH6kYUQF9JSQeX5iBsw1dWHdllsnHnT9/flAEkSKRyGzJC5FIhNGjRxvNTdTPbKr7jeWbY9jV1cU7b7KlpQU+Pj72NptXQkICe9xDQ0Nx8uRJzvqgoCC0tlrfy0yIO6Ag0gYSiQQCgQCNjY0ICwtz+sR0jUYDhUIBmUzmtCxgQ5W7HzuGYaBQKNDY2AihUOiUVOGEEEIGrxM1HVi0iVvX8cE5I5EVEwAviQg+UuNTuOWXJBktG6wCAgLQ0tJidhv9Hkgday/Onj592uS6ri7Twbs9QkND4efnBw8PDwgEAmRnZ+PYsWPs+uTkZBQUFHAeo1Ao6NyAuDUKIm0gEokQGxuLqqoqdjK3MzEMg97eXnh5eQ2aTGruYrAcO29vb8THx7tloEsIIWTg9SrUuPegGDjIDSA/v2MixiUGO+Q5GIZx699GwHQw6Ovra/Zx1mZ9NzeqzBm9glKplL2tHxzqbmdkZODkyZPs6y4rK8PIkSMd3g5CHIWCSBv5+voiNTXVqF6QMyiVSuzbtw9TpkyBRCJx+vMNJYPh2IlEIojFYrf/ISeEEDIw7vqoAF//ehRCqS8EHl5glDIIJFKcfnY+pGJtr5tarUZvb6/FYMqc8vJyREVFwdPT0+591NfXIygoyGm9ZaYurlrqJXTX33xT/P39AQBeXl4YM2YM2yPZ1dWF06dPIyYmxuHDawlxBAoi7SASiXiHUDjjeVQqFTw9PQfdl6Kr0bEjhBAymNS1y7B9bwE0il6oezog8g6EuqcNux+eywaQAFBcXAyFQoHk5GQEBQVZtW+JRMK5+N3S0oKWlha7E8WcPXsW7e3tqKqqclqyGXfJGaCfwMcZ9HsoDXV2duLkyZOU0Ie4JRpDRwghhBDiQLYGQE1dckx47mdoFH11CJdk+uK7ey6BrIfb86ZQKADA4nzB/rTHkvb2dofuj09bW5vdj9VlaNXP1GqKuSAO0PYQOhONRiKD1ZAKIjdt2oScnBz4+/vD398fEydOxA8/mE6NTQghhBDiSJ/u2Iu3tu3mHXbJMAy+KqxCZUsPu6yhQ4axz+zmbBcoYXDt2Fizz2NtkKXRaMxmOR1scnNzLW7j7++PvLw8xMXFsctGjBiBmJgYznbJycnIyspCcLB2rilfQNefYNYa1gSR7tIrS4i+ITWcNTY2FuvXr0dKSgoA4P3338cVV1yBwsJCZGZmurh1hBBCCBnKFryyH4cPFwEAIv09ceXsKQCAypYeTP7XL1bt47PbxuGPQwcd1iZz9RZVKpXViWjcha3tNRwKGhkZabRNUlISWxvSMEsqXxkQR4iIiEB7e7tRuRVfX1+jCxCFhYUAjF8LIa40uL45LLjssss495999lls2rQJhw4dMhlEyuVyyOVy9r7uy1alUg1I8hxzdM/v6nYMRnTs+oeOX//Q8Rv86D3sn+F2/I5WtWPxW79zlu2v6MFCpRJfF9XggS+PW7WfL24fDzDaXieVSsUu1z+Oppab0tDQwHmMvtLSUiQnJ1vVNn22tsEeYrEYMpkMAoEAo0aNQnFxMUJCQiw+X38/e4bHKigoyCmvMSIiAhEREVCr1Zye4rCwMLS3t/Nmj21qanL6HE134G7fH6b+foY7AWMux/Egplar8fnnn2Pp0qUoLCxERkYG73Zr1qzB2rVrjZa/8847g6IYLyGEEEJcR6YCHv6z75q8vO4sAEDkEwixn/XnEc+NU6Gm/CzvOt0IK0Cb1IZvuSkNDQ3o6Ogwud7HxwfBwcEW5wbq02/DiBEjnDKvr6mpCW1tbQgKCkJISAg0Gs2AlMPSf20AEBISYnUCI0fRaDRoa2vjnfdqzXtOHKupqQkrVqxAZWUlYmPNDzMfToZcEHns2DFMnDgRMpkMvr6++PjjjzF//nyT2xv2RFZXVyMjIwNlZWVGY+cHmlKpxK5duzBr1izKMGojOnb9Q8evf+j4DX70HvbPcDl+vQo1cp7+mbOMDSK9AyH25waRHy0fC0+xyKjX8vRTsyAQCHD48GGoVCocOnQIEyZMYIdu5uXlsdsePnyYva2/3JT6+npUV1db3M6afekUFRWx8/RGjx7tlODu7Nmz6OjoQGhoKOLj461+XH8/e0qlEseOHWPvR0dH8w6BHQj677WOLe/TYOVu3x/V1dVISkqiINLAkBrOCgAjR45EUVER2tra8OWXX2Lp0qXYu3evyZ5IqVTKufqmu1onFovd4oMLaFNzu0tbBhs6dv1Dx69/6PgNfvQe9s9QPn4v/XQKr/6Pv+cQAKDXO3fThAQ8vSiLvf/jyikI8fXA4fOtmJwaBg8PERiG4cz3E4vF7H3dMTTcpqOjAwzDwMvLy2QtwZaWFvYxsbGxqKqq4t2ut7eXrVloiUQiYYdgSiQSpwSRPT09EIvFaGtrw4gRI2x+vL2fPYlEwjnGvb29LvsM883/lEgkYBgGLS0t8PPzc1qdTnfgLt8fg23e8EAZckfFw8OD7eofO3Ys/vzzT/z73//GW2+95eKWEUIIIWSw0mg06O7uRg8jxkXr/me0/rpxcZgxKgI3/+tCYHkhiFyQE8UJIAFgZKQfAGB2Zl8PV1NTk9nnFgqFRvPkysvL2dumkq7ozysLDw+HRCJBWVmZ0XZnzpzB6NGjraqDrd8OpVJp01DYwcaVQZqPjw+6u7uNlut6aQEgKioKUVFRVCqEDLghF0QaYhiGM1yVEEIIIcQWrd0KZN3/PjTyHt65jg/NHYk7p2kvYN82OQn/2a8N0rbdeTHy4q2bT1dRUWFyXWdnJwICAniTreioVCoIBAKzQaBAIEBwcDB8fHxw/Lhxsh+1Wg2NRgOBQACNRmMygNIvOdHd3e2UINLLywu9vb0uG0qqk5iY6LLnHjlyJGdIq5eXF+RyOWeOa21tLdrb2zFq1ChXNJEMY0MqiHz00Ucxb948xMXFobOzE5988gn27NmDnTt3urpphBBCCBmEGjplGP/sz9DItbUd1d1tnCDy7LPzIBZpewkFAgGuGB2D0XGBSB+RgAwrA0hLWSjPnj2L/Px8s1kijxw5AsC6MhCmgj6ZTIYzZ86w9zMzM+Hp6Wl2X866UN/b2wsAvPU2nS0nJwdHjx5FRETEgD+3PoFAgPz8fDQ1NeH8+fMAwBv89/T0GC0jxNmGVBBZX1+Pm266CbW1tQgICEBOTg527tyJWbNmubpphBBCCHFje083Yul7fyDCX4rfH52JU3WdaO1R4Lq3D/FunxHljx33Tgag7Zk7cuQI20OXEOKD3rYmAAlWPbe1gZI1wYJMJrMY+AHaAPHEiROcZfoBJACcPHkSo0ePNnqsQCBge0WdnTHVFUGkRCJxq5qMuosMusCaEHcwpILId99919VNIIQQQsgg0tAhw/h1fRlW6zvkKKntwLx/7zf5mG/vvgRZMX1JaDo7OzlDPE1hGIYdnpienm4yGQ6fgoICqxJ8VFZWIjU1lb0fFBSE1tZWo2DP09MTERERqK+vN7kvtVoNpVKJo0ePAgACAwMxYsQIzrDa6upql/fYDXXm5svqDFQJFEJ06NNGCCGEkGHpl1MNnABSx1wAedOEeGTHBnASmegXizfn3Llz7O2TJ0+yQ0GtHRJqTdFzw5qQul5JvtrXsbGx8PX1Nbs/XQAJAG1tbSgoKOCsd0aluCFWfa7frDkefDUlCXGmIdUTSQghhBBiikqtQVlTN2Zt3GfzYx+Zlw6VSoNLUo2DsZqaGt7H9Pb2wsvLi73f1tbGWV9VVYURI0YYBaFRUVEYM2YMp16hLRobGyGXyxEbG2sxABk5cqRRYGir6upqh9bW1m+zqxPruIOQkBDU1dWZ3aa9vZ33QgEhzkJBJCGEEEKGtOq2Xkxab1yWQycrxh/v3zIe+c/s5l1f9tx83sLvOqYS4xQXF5udW6cLKhsbGznLfXx8+lWyQZfp1c/Pj+3ltLa31B51dXUIDAy0aXiuOZ2dnezt6Ohoh+xzMPP29jZalpKSgrNn++qUGl6gIMTZaDgrIYQQQoakP8pakPjI92YDyDPPzsN390xGiC9/xtK/Vs+0GNBZM9zQ3JxJ/QBPP5FNWlqaxf2aU1ZWhtbWVgBAc3Ozye34kufYGhCePHnSpu3N0Q+OqP4hN6jWCQgIQGxsLGcZZWklA4l6IgkhhBAypBTXdGD+K6bnNebFB2JcYjBWzTddW++mCQlYvXAUpGLjuou6ch62sHZoqn5yFD8/P5uew5C1vY+GtSUDAwMRHh6O06dP9+v5iWMYlmTR1e+MiIhAVVUVu9xSqRhCHImCSEIIIYQMeh0yJZa8dQidMiWqWo1LIRx+fBaCfTzM7mPHPyZj/iv78dWdF2OMlTUeAe1Jvkwm412nUqnAMIxVSXHcxYgRI+wqrdHa2oqgIOuPG7GOYbBoqle7u7sbAQEBA9UsMszRcFZCCCGEDGrNXXLkrPkJJbUdRgFkeqQfytcvsBhAAkBGtD/K1y/gDSD1ewgNh68qFAqT++zp6TEZYLozS1lb+Zw7d86qUiem9OexQ11eXh57W7/neMSIEezt2traAW0TGd6oJ5IQQgghg9b2wmqs/LSIs+z1v+VhQU6UQ5/H19eXLZ9hGESaC37OnDkDf39/k+t1cxZNSUpKQllZmQ0ttU9mZiYqKysRFdV33OLj49kkPcnJyZBIJDh16hQAbSDDN1y2sLAQeXl5Ng/3lcvlOH78OPVkmiAQCJCamor6+nrEx8ezywMDA13XKDKsURBJCCGEkEFFrWHw1Lcn8P7B85zli0ZHY+OS0U5JxqK/T41GA5FIxAZUlhjWbtSnXzuST3BwMIKDg/tdhiMxMdHsek9PT6SmpnKW6fe+BgUFcXpUU1NTUVlZCV9fX9TX13MeJ5fL2fqU1tLtQz+opsysXP7+/mYvSABAQUEBEhISTJb7UCgUOHXqFMLCwqh8CukXCiIJIYQQ4vbaehQY/dQuk+s/XnERLk4ZmDp5R48eRWhoqF3zBg2JxWKr5kt6eHjwDpuNioqyahijRCKxuW2BgYGQSCTs0Fb9HliGYZCeng4ARkFkc3OzVXUjGYZBaWkpvLy82FIk+mh+n33Onz8Pf39/NgGPvurqaigUClRXV1MQSfqFgkhCCCGEuC2GYZC0aofJ9clhPvjm7kvgK3XuKU17ezvnflNTk0P2a23CndTUVJw4ccJouY+PD1JTU3HmzBmzj7enhqNIJEJ2djbbC6ufJdTLy4u9HRoayjkedXV1bBCpUqlw5MgRAEB+fj4YhsGJEycgl8uRlJSE9vZ2o2OrY2tvJulz5swZZGZmGi23phwNIdagIJIQYrfa2lrU1NRAIpEgMzPTKE08IYTYq7SxCzNe2mty/UcrLsKkAep5tKX+XlBQkMV5jrm5uWxgZS1TPYkeHh7w8vJCTk4Ojh49avLx9n4/6w/jFQqFyMnJMdqfYRAJaGs9pqSkGL3O0tJSttfR0lxP/eG0xLSIiAij3mBTyZz0P5sFBQUYOXIkbxIljUaD2tpaBAUFwdvb27ENJkMCBZGEELswDIOamhoA2tpUlZWVFufcEEKIJb0KNe78qAC/nGo0WvfFHRMxNjF4wNtUUlJi1XZxcXEIDw9HY2Mjm5DGkLmkM7oAjY+pgErXO2jPcFV78D0PXy8nX+9iT0+PyV5HYr/Y2FijIBLQBpK63lyGYXD48GGjbU6dOoX8/Hyj5dXV1WhoaEBdXR3vekLoEg8hxC6GRY2bm5td1BJCyFDAMAye+6EEo57YyRtAnn5mnksCSFuEh4cDAMLCwnjXx8fHm036Yy4QFAgESE9Px8iRIznLremtc1VPkmHvpLXBOLEd39BV/eHPpaWlNu2voaGBvd3b24uqqioaCks4KIgkhNiFL7U7IWTw++VUAxIf+R4nagaux6i2vRdJq3bgrb3cTKWvXj8Gpevmo3z9AniI3fuUxTAA5Cu9YCq4tJaPjw98fX2RnZ2NmJgYjB492qrHBQc7P/geOXKk0es7f/68ia2Jo3l6enJqSRqy1ANsrp5pcXEx6uvrUVhYSLU8rfTGG28gKSkJnp6eyM/Px/79+01ue+DAAUyaNAkhISHw8vJCeno6Nm7caLTdl19+iYyMDEilUmRkZOCrr75y5kuwyL2/kQkhbkej0UAmk3GuUupQYEnI4NWjUCHxke9xy+Y/AQALXjng1Od78cdTSHzke6z99gQmPvc/zrrllyTh5NNzcVluNERCx5frcIaUlBTOfbG4b8ZQWFgYcnNzHfZcHh4eiIyMtHqeY11dncOe2xRfX19O/cL+ovqHtuPr5bY0PxfQ9jqWlJTgxIkT7PxfvsyuDMPg+PHj/W/oEPfpp59i5cqVeOyxx1BYWIjJkydj3rx5Joe4+/j44O6778a+fftQUlKC1atXY/Xq1Xj77bfZbQ4ePIglS5bgpptuwpEjR3DTTTfh2muvxe+//z5QL8sIzYkkhFiNYRgUFhaaXF9UVIS0tDT4+fkNYKsIIf1xrrELl5pJYGOthg4Zxq/7GQBw5unZvNv0KtTYVliFx77qOxHd/Gs5e/vvU5Oxat6ofrfFFQyHjMbExECpVCI0NNTlAZG1GWAdwVQpElu1tbX1vzHDUEZGBoqLi9n7586dQ35+PoRCoclexMrKSvZ2a2srvL29Tb6HhlNZhpPOzk5OzVepVMrJWKyzYcMGLF++HCtWrAAAvPzyy/jxxx+xadMmPPfcc0bbjxkzBmPGjGHvJyYmYtu2bdi/fz9uv/12dh+zZs3CqlWrAACrVq3C3r178fLLL2Pr1q0OfZ3Wop5IQojVrLmiefr06QFoCSHEEZ78+rjJAPISKzKfnqrrROIj3yPxke/ZABIArnjjIO49KEbB+VYoVBqs2nYUiY98j1FP7OQEkPoCvSWDNoDkIxaLkZKSYjKANDc30l7ucAEvOzsbERERNj8uIyPDLdo/2Hl5eSEjI4OzTKPRWD0Mla9ep6HhOjcyIyMDAQEB7D++gFChUKCgoACzZ3MvpM2ePRu//fabVc9TWFiI3377DVOnTmWXHTx40Gifc+bMsXqfzkA9kYQQq1lKx85HpVLh7NmzCA4OZpNOuFpBQQF7m7LOkeHmsz8r8dKuU6jv4D9ZfGZRFlZvPw65Sjs8nWEYdCvUnDqMDZ0yjH/2Z97HA0BxbScA4Lp3/jTblmcWZYEBMCcjAuH+7lkTsLe31yn7zc7ONluSwx5paWnsbf3vuYFmKluovvz8fE4bvby8EBkZic5O7WeHSkbZz7C+pi2J76zJ8iuTyTh1QoeL4uJitv4pAN5eyKamJqjVaqMLKRERERaHlcfGxqKxsREqlQpr1qxhezIB7ZB0e/bpTBREEkIsKioqMjnfMS4ujjMUxtCpU6cgk8nQ3d2N8PBwMAyDiooKeHt79zvJhD0sXUHVaDQ4f/48AgIC0NDQgO7ubiQlJQ1IYgpCnOm5H0qMEtfoK1+/AADwc4n25L+9V4mXd5/Gy7vNF7G3l+753N25c6aPmQ7fyaQl1iTiGapGjBgBQDvkt7q6GsnJyUbb+Pv7D3SzhgzDXu6qqiqrH2vN0OfhWr/Tz8/P6s+l4XvAMIzF0Qf79+9HV1cXDh06hEceeQQpKSm4/vrr+7VPZ6IgkhBilkqlMpswR1eI+NSpU7zrDbO9nT59Gl1dXQD6n6nQHoZB5OnTp9kr31lZWSgrK0N3dzdaWlrYbcrKyiiIJINSW48CB842YdrIcJMBZOHjsxDk05dEQ3ghkc3p+i6crrc+gNx9/xSoNAzmvsyfhfDE2jnwkQ6+0w5Lc8BGjBjhkADQkUlpDPEFac6Wn5+Prq4uSKVSox5X3fGKjIxESEgIG1DrByfWTJ8g1uEbyiqRSHg/2y0tLZzfP6lUivT0dBw5csSpbRwqQkNDIRKJjHoIGxoaLA7zTkpKAqAdpVBfX481a9awQWRkZKRd+3SmwfdtToiD9Pb2oqurC6GhoU6/ktPU1ARvb2+X1erqD1MBZE5ODjQaDSQSidEVdbVazTsUSSaTsQEkABw/fhzJycns+zAQVzcNf0x1AaSuPaYolcoBK+ZNiCMcrmjFVW/wz5eZnx2Jy3KiMS87ymjdgTNNPI8w9vSiLMxID0d0IHdY2+yMCAR5S3CxpBzz588f9H83ht+BusQxSUlJEIvFDusxc/Rx0h8lEhQU5NB9W8vX1xcAEBISYnJIpf7rtqdHl9gnOzsbhw8ftrhdamoqxGIxsrOzcezYMQD2zYmUy+Vob28fsN96V/Hw8EB+fj527dqFK6+8kl2+a9cuXHHFFVbvh2EYzvzUiRMnYteuXbjvvvvYZT/99BMuvvhixzTcDhREkmHr9OnTUKlUEAqFCAkJcfj+GYZBe3s71Go1WytrMM6/40tJLZVKjU540tPTcfLkSQDa4a98r1WXOlxHLpezxac7OjqMUuQ7g701ro4ePToo3z8yPB0404Qb3+VP/W5pGOm1Y+Pw7oG++c8Lc6Lw3dFaLBkbB19PMXJiAzArIwLeHvynEG/fPBZKpRI7dpTb3X53lpqaCoVC4fbDLcPCwuDh4QEfHx9XN4WT0dIct7jgoFYCnbVAQwlQcQi46O/A0c+AllJgwUbAHQOgljKgoRhIXwD0tGjb+94D2nWznwGSJhs9xNqL57rAXr/kR2NjI+Li4mxqYnFxMTQaDZRKJWde4VB0//3346abbsLYsWMxceJEvP3226ioqMAdd9wBQJtZtbq6Gh988AEA4PXXX0d8fDzS09MBaOtGvvjii7jnnnvYfd57772YMmUKnn/+eVxxxRX4+uuvsXv3bhw44NxSTOZQEEmGLd24//LycocHkXK5HC0tLaipqeEs7+3tHXST0fl+/HVDLvTx/SAZXsE3l5jHUiFkR9HveSRkqDIVQBY/NcfiY0dG+uHL/7sY0YGeiArQfl+99jeHNm9Q8/T0NEpc4o4EAoHbzLO0pyzEgEx3YBjgkxuAU9+b3ubAhr7bBVuANQPzW2VWVQFQ8g3w68uWt/1pNfB3bQZmPz8/KJVKREZG9uvpGxoajIJIjUYDhUJh8m9DdwG3ra0NPj4+8Pf3H7I9kkuWLEFzczOeeuop1NbWIisrCzt27EBCQgIAoLa2lnOBXqPRYNWqVSgrK4NYLMaIESOwfv16/P3vf2e3ufjii/HJJ59g9erVePzxxzFixAh8+umnuOiiiwb89elQEOnmqHi746lUKk4RaB1LX4DWUiqVJodFFhcXIy4uDuHh4SaHfDqLI5+P78q2/lBdXUBp64nDQByT/mRa7OzshK+vr0snshNiSeIj/CfE+x+abrL30FB+gmuGP7q7/p58G8rJycHRo0eHfM+MPmu/450eqDeXAq/m2f64o58DOdfY95xfLAeOf8Fdtux7IPES84/rrAM+WwqMWwF8dx+gsHwxNNxHgIZu7rBTjUaDzMxMW1ttlZMnT6K3txdxcXEIDAyERCJhfyv1h2XKZDKUlpYC4BmddeQTYPcaSDprcQUAVezrQP6NTmmvs91555248847eddt2bKFc/+ee+7h9DqacvXVV+Pqq692RPMcgoJIN9ba2oqysjJUV1cjMTHR1c0ZEhoaGlBZWcmbZKCwsBBA/5MkGA7ZNFRZWQmlUom6ujrEx8cPyNXWc+fOobW1Fenp6TYNbbJ36Ke9gWBRURHS0tKcWiuM78qnYap5fQKBgJ3/oauBScNaiSPUtveiR6FGW48CizcdxOi4QDyzKAvrfziJF6/JRWSA7SfRN77D7YE8t24+myiH9J+j5xZKJJJh8X0iEonYi+LZ2dlmt01MTER7e7tzfhvVKuDsbmDrEvv3sW2F9p+1PZKWgtUtF4aXh6QAzWe1tyOzgTsOAN3NwMZMQHXh4mflIaubKdH/GVarAJHYaLiw/u8bH2vKcukyhOou0FZWVrJzcfPz89Hb24vi4mLex7Kjs6oLgP9carReUP3XoA0ihwMKIt2Y7o+wvr6egkgH0R1T3RxFHf2U1qWlpcjPz0dtbS1nOKq1AZg1wzN0GbYqKioGJIjUZbk7efKk1eUqzp49i6KiIt5eW0t0x9OenvTTp09j9OjRTuuRNDU3JyAgwGhIrUAgQGZmplHPsrm02ufOnUN7e7vdATgZXDQaDYqLi+Hj48M7zBsAZm3YizMNXdh13xTcs7UQ7b1K1LbLjLYrqmzDwle181smPPez2bmLe083Yul7fwAA9j04HfEh2pEAB872JcU5sXYOBZAOplAoBmWCNFdLT0/HiRMnIBaLLX63h4SEOCVPAQDgaRP7nfUUMP52oKcZCIjVLiv9BfhwETDxbu2ynY9wH/PhVcBN20w/14ntwOdLrW+bLoAEgLpjwJoA89vfXQD4RwMiD0AoAgx+kwJKD6L6+VnaO+/MAAB0CAA8+DWQor1vrs5gSkoKAgK4bQgPD0dDQwN731It0s7OTk6mVxbDAIc/QM37mzEimP+cqc0rET5jbgJVC3VfFEQOccePH4dcLkdWVhZlPdNjGNzof4lGRWmzFRrOZzx58qRVV4ztyVo2kOwtVxEaGor29nZkZGRY/Rh75sEA2my2hmmre3t7UVZWhpiYGKMfNlt0d3cD0CYJUKvV7JXWlJQU9gcxJyfHbIKH3t5ekyeSra2tUKlUVtWWI4NfcXEx5HI55HI5G0QyDIOq1l6E+kox9YVf0NCpHco1a+M+MAwDVWsNBGIpxP6hJvfr58n/81xc04H5r3BLaEx54RejgPOmCQmDspyGu3PmKImhzNPT0/U9rnxB2RMt2gBMRxdAAsCI6dzexrpjQNFHffdLf+bui2GAt6YALeeA/GXAwdf42/FkmzbgWxsEMHZcbMxYBFz7vuXtIrKMFo0KEwL/vQqImwAs+w5orQBkcsDTD0FBQWhtbYVQKMSYMWN4d6kLIkUiERQKhcUm6EbvAAA6aoBfXwEqDrKL2vgedM9hKP3jsXfHDsyPzLH4HMR16BfGjVlT8NUS3Tj048ePu/4L3I3V19ezt81dJa2trWWDTFP6M+fOHWg0Gt4ASDch3BaGNSKtxZd8SDcc5uzZsw75LGs0GuTm5nJ6FPPz83l7GQ3raZ0/fx49PT3w9PREQEAA6uvrkZaWZnSh5vDhwy6d9E6cT3+uT3l5ORITE5G0aofJ7TWyLmgUvYCi12wQ2Snjfv8XVbZh0eu/mtx+V3E9ZmVEINxPioZOOa4f77yag8PZQM5jJw7EF0DamiBn5hpAowKOfmp+v4BxAHnPYSBkBHfZw+XaTKqvjO5b9mQbsDZQezswHljykbanMTxdG6TaMh9fJAY8fAGFtqxWXpSw77et8hDwdCg07RqgmwFu34Pk5GSLxet16xiGQWNjo/nn724GfEK07d75iDbTLY+CGu1F/ZHrz8E3+MLwWTsvQJOBRUHkINPS0gKFQoHIyEh2Xl1oaCh70n3ixAkIhUKMGjXK4tw8wk//pNBQTU2NxSCyurra0U0aUDU1NWhra3PIvnRBpP58GGvoDwWtqakxGoJaV1eH6upqZGdnc9KOW6IfCAYFBfH+WPIti4uL4wTWur8tmUzGvkbOFVc9nZ2d1HsxTDQ0NmH2GwWA0PRcRlV73wUrjVKGqJAAvLdsHGKDvJG79ieoOpsg9PCCUNo3dN5Uohx9t33wFz77+0Qo1dq/HQ8xDWMlg0hXA/BiKnfZ6BuBRa/3f98/PGK87IGzxsss8Q0HrnpbO1/xp9XWPebq94CsxfzrPAO0/279Cdj3L+C6rdog0VRwa2NCN4ZhgFu+15b/EIog2L/MaBul7qf27WnA2C6LSeN06zUaDXcYbFsF8P2DQBf/0FheeTcB+beyJVNOlVUiP9jyHEziPtwmiNyyZQuuvfZammtghkqlYkskSKVSVFRUQKVSoaGhAXl5eZwTWrVazdub1N7eDoZh3Cbttzuy9CXa1tZm8vh1dXVxhrNmZGRAJBKxBXpdge9iQmlpKdra2pCcnGyUKIKvBIbh0FJrKBQKtrg0XwCZlZWF5uZm1NbWGq07f/48AgMD0dHRwbteF6gfP34ceXnWZ9fTf29seU1BQUHIyMgwmRzAnNOnT9MogGFAN5dRHBABkZcnGIaBpqcdQqk3BOK+Cx1iIZAY4oOXrxuDxMREaDQaVFSchVdoNooemYRRK9+HursN0sgUs8Hj/oemY/K/fuEsu/atvmFiEtHQTJ1PBqnv/6nNQJp5JXe5Rg08ZWJ6RdF/7Q4iE5v+B+GuX4E/3uKuWPE/ILaf38f1J8yvv/cosPU6YOZaIG225f3FXwTc+GX/2sSDvcAafGGu9oOlwAvc3tDWXr3pN2sCgJRZwPWfaHsxeQgYBvhrs3ZYr5q/t3BEsBClLfzDdHPveh/qkQvgIZXi8OHDRuvlcjlNvRpE3CaIXLVqFf7xj3/gmmuuwfLly3HxxRe7ukkuZ5je+siRI+xtwwCxvLycc6JeWlpq1KPW2trKPs6ZiUvclbXz8xQKhdneyNLSUpPH79SpU5z7uh7i5ORkl82RO3vW+Iqrrqfx3LlzyMvLQ3t7O7y9veHh4WEUdAYEBCA6Otqq5woJCWEDxxMnuD+0MTExnF5aqVSKqKgo+Pj4GLVRpVLhxIkTFofD2jr/VH+Cv60/VJbqe/r5+VENymGqV9E39FTT0w6Rlx80PW1QdTYDncDcqRORGR2AOZmRaK0IheeFtInl5eXs444dO4a4uDjccnEiNv9WDj7/mJGKhGBvjE0MQlywN37+51TMeGkv77YURDqGud+CYYdhtPP4cOF7d/IDwIzHTW//13vachQ6f74DfL4MePAc0FIKvDvL8nPqDxdd+i2QNIV/u/ZqYKN2vr4EQC4AVPJs198AEgDOGsyFvG4rMHIet6fwzoNwNaOkeD6h2l7OL28Djn0GxE2AqO5XqPXjvbO7gO/vA2LygT3rgU7uRVyBhgHqTM/jTAwUINCT50L8DV8AvmEQ5+abDTxo6tXg4jZBZFVVFb7//nts2bIF06dPR1JSEm655RYsXbrU4XWZBgO1Wm3TfDLD7Fd8J7P6QUxNTQ1iY2OHVb07w6DGlLa2Notprdva2hAcHMw5foaZPV1BrVZDoVBwAh5LwXN5eTlaWlrg6+uLkSNHGq0fMWKE1Z+TuLg4NojUaDRsYBUZGck7ykAgECAgIICtlabP3vmU5vR3qHFYWJjJeSC2DKu1RC6XQyQS2ZUZlzhXb28vPDw8OBeRrnmrb66PRinD1fmxGBsUBk9GhqgAL4SHhbJJdwrqTb+nMpkMC3OjeIPIO6aOwP2z0jjLRoT5ouiJWRj91C6j7cP86Gp+f6nVarowBFwIHgONl+9/EZj+KDcxjY65zKIvGJfYAgCMmGGcrEZfiZkgcqMVCd8erbG8jTWmPAj88KD29oOl2uBsMFn8H+DS1YB/NOJmnEb5p49oM9HqHP5A+4+HyES251FRfuhZcQAhUbGAWAoUFGiHKEv9AYm2QyQri5voJy0tjXcaiEqlQnd3t9snKSRuFESKRCJcfvnluPzyy9HQ0ID//ve/2LJlCx5//HHMnTsXy5cvx2WXXWZV+YShwJqsV/3R0NCApqYmNgMXwzCQy+XOL+7rQrbMybO0bXl5Obq6uhAaGsqW/TDsTdPPgOrIAMMUhmFQVFQEQPvl7OnpadXfi+4CRFdXl9E6sVhs04UGw95Z3QmYRCLhzHM07NmUSCRISkpih2s7gyPmeUZHR5sMInVZXwHj91utVlvd869UKnH8+HGzGfKIa3R1dbGjDfLy8pC0agcU9dy/+7unp+DRq3Nw5swZ9vPf0tJisvyHvsbGRkjFIggEAKNRQ3Dh5PzjFRfh4hT+E9VAbw8khHjjfHPfCILVC0ZRT6QDHD16lEr1lO0H3l9oen1HDRAY13f/yKfAV7fb91w3bdPWMwQDPM3zeReY+A41EbCqL30CoktW8ge5/TFuhTZJTtRobeKYQSAmJoa7IEibKC8kMRPym96Cr1QMvJrK80gTLl0NxE8EJN6IiomBd3Q0jC4T+/ZdjA8NDTUa/ePn58dbo/nIkSNQqVRoamoCcW9uE0TqCw8Px6RJk3Dq1CmcPn0ax44dw7JlyxAYGIjNmzdj2rRprm6i0xlmZnXGD5lGo2EzcenGpsfExCAyMtJihq7BRv8E3xqlpaXs7YCAAPj4+MDb25sTKDY1NaGpqQkikQijR4822kd8fF92RB8fH4SFhUEqlaK1tZXTHplM5pDgXX8o7dmzZ6HRaIx6/1JTU3HmzBmT+zAMhB11UaGzs5NTY5OvNmZwcLBTg0j999Re+j2DhkWa9XtOY2JiEBsby1mn//ot1ZkEtH+fTU1NCA0dZFe5hzD9v48R9/4XSoUC+hfLH18wChclh+DUqVMmv3OsGfb8zV2TcOWHZyHy8jNbK1Lnw1svwmd/VWJKWhiiAjwRF0y5BRxh2AaQDAMc2gT8uMp43c3fAMlT+wK3l7P6ymS8kAJ0G1xku/YDIOMK4Jt7jHu3kqcBV2/WJpcRXLjooZuLN+FO4NAb3O3PG2QnbjoDvDaW9yV8Pfp9zJ+4ACJHB5CANhHMhTqLg4W5klXsRd07fwfeuJBN/KavgMQp/HMjDYI+ay5WmzuXyM/PR0dHh9G5iS6HB3G8s2fPorS0FFOmTIGXl5fd5/xuFUTW19fjww8/xObNm3Hu3DksWrQI3333HWbOnIne3l6sXr0aS5cuNSoUPxQZ/sE5a6hkd3c3fH192fvV1dUQiUSoqqrCiBEj4O/v75TnHWim5iNGRUUhOjoaFRUVJnuY4uLizM6f4+u1DAgIMOp50gWVERERbGIbQNtD5ogh2/onrbqTH/35jbm5uRaHRxp+zhwVwLS1tXECWlNfVoalNAx5eXk5pISKLbUuDaWlpaGqqgrx8fE4efIk7zYeHh6cv2H9k1HdVVdTtVv1e4TPnz9PQaQb0f2tazQMejuMC2hflKztlTAMIPXrmkqlUotBpEAgwN57xyM52cSwPwPxId54YI7xUHTiWPoXhoYkU8NWde49yvZgcXy5Ajixjbts+mPA1If67l/+KjDrKcDDD1D2AJ4Wzi3mPqettfjzU8DJ77TL6vSmPJR8B3x6A/cx120F0udrf0N2mC6zM5xERUWhq6vLutrQ4em2lz0BeBMNRkVFcZLiWZqeYupcs6KiAikpKTa3ifBrbm7GkiVL8L///Q8CgQBnzpxBcnIyVqxYgcDAQLz00ks27c9txrtcdtlliIuLw5YtW3DbbbehuroaW7duxcyZMwFoTx7/+c9/orKSb6b00GN41YgvCHJEYpyKigqjP+6KigpoNBqzPVZDha5HLD4+3uRkbnsyhVk62dAvE2Jvj29bWxtOnDiBnp4ei1fMvb292QBSN6zEUiAlFosdlsXX09OTM8/U1Gc3JSWFN9BNSEhAfn4+0tPT7Xp+/eEyQUFBFpPkmOPn54dRo0bBx8fHZHv0ex0B7TDFzs5OHD9+nF3miJ5R4hpfFRrPrV050/RQMP3hzdYO0TL8DBHXsydL9aCglGl7FvkCyJBU4Oavtb2NfAEkYBxArqrmBpA6XkHani1LAaRO2Ejguo+4y9YEaP8ZBpAAkD7fuv0OI9HR0UhLS3PqyDK+cyTDUVD2zi3W5VggjnHfffdBLBajoqKC8x4tWbIEO3futHl/btMTGR4ejr1792LixIkmt4mKinLqcLfBxpY5fqYoFAqrE84MZny9W35+fmaHeNhCP0iRSqUWh4HqBzH2Jk/RBSElJSUWs6fqP19CQt+JgK48Bl+q7cTERLvmIEdGRnLrR0GbnVYkElnMuubt7Y3c3Fz09PSgpKSEXa4b3s33Q6jRaIzaef78eTQ1NWHUqFFGP2ZxcXFwFB8fH6SkpPBmwNXX2tqK1tZWzjJrL050d3dTQOFm+BLfXJpuOsDQ9UzaMjSrpqZm6AYtxH0c+wL4crnxcsOeREN3FwCv8Xyfr6oGpL7Gy/tj1tPALjNZYOf9C7jo7459TmIVHx8f3t9lw99k/dEYtqBeSMf66aef8OOPPxp1dKSmpto1ytNteiKnTp3KW+9NoVDggw+04+gFAgHnBHios/ePzpDhfL3s7Gz29lAZrmqJvePq7Uk1rT8X0hSBQMAee8P5r/aoqTGfdc5UsXuBQACBQIDc3Nx+t0EnJibG6DNna8+ft7c3Ro8ezf4Q6WpZ8v1YGQZnQF9vT0lJidHQQkdnPLX3QoS1iX5MDZkl7uHruybhu3suQWyM6Qs5us8I32fVlGE7H48MnJ8e5w8gAfMBJACEpgBeekMkZzypHQrp6AASAERmvmOv2UIBpAvxZXQHjM+5rLkgpj9CC9Be8B4u56gDpbu7mzdTflNTk12j7twmiLzlllt45/11dnbilltucUGLXC85OdmuE1TDoYKG9yUSCTvPypaTmuGGr8xHXl4egoODzV7MsDazriN6kq1lqWdULBZbN2fCSiKRiL0IwpdEx9p95OTkGM0dzM3N5VwIMQzCOzo6OPcNj7Ojh/WY+xu19MNpOA/X1GeCAgr3Ud7Ud1Fi6cQENuW9ue9Se3oi6eTJvbhlqbG2CuAcf51Qi9YEAL+90nc/aap2zuKklcDD5dbt44HTQMxY4Kr/AJPvt68d1hhzo/EygUgbtGZe6bznJRaZ+j01PO+0JkN9dHQ0Z6SQo0aKkT5TpkxhO+YA7fun0WjwwgsvYPr06Tbvz22Gs5rKDFRVVeWwHrnBRiAQWDX0zrB2XVBQEIKDg3H69GneeW8CgWDYpU42LHRvjZAQ49TdAoGATdXPMAwqKiqMtuG7ysNH93k3DBDkcjlkMhnnc8+3jE9CQgJEIhHa29sRHh4OoVAIhUJh1XDIpKQkCIVCtLS0IDs722hIqq2Sk5PR2dnZr5NhkUhk9GNk2JOoCyLb2trg5eVlNJdXfx61fvDpKOZ+6BoaGszOXe7q6uIE2aaCjK6uLgoq3EBLlxx3by1k718ztu/72cPDw2TSJ3tGGwzX3z13Yfi97FY1W0/9AGy9jrss92/ApH8A4aP6lv32GvDTY0D6QuDKt4DeFiAwHnh9Avexk1YCs9ba3g6RBLjNTF1HR5H6AasbAGUv8PyFC7j3Fjn/eYlZzhhuHx4eDi8vLwiFwn6fgxBjL7zwAqZNm4a//voLCoUCDz30EE6cOIGWlhb8+uuvlndgwOXfimPGjGGH1M2YMYPzRa1Wq1FWVoa5c+data/nnnsO27Ztw8mTJ+Hl5YWLL74Yzz//vMnu9sHAmjlpMTEx8PT0hLe3N3p7exEcHGzV/LPhxJ6eHEvBIF/Xf0REhNVBpC4LZ01NDWcYhy75SmpqKhs46JZ5eHggISHBZOCi62HWDf8EbCvTkZCQgISEBLMZUq0lFAoH5ERYIpGgs7PTZKIa/cRRA1GvU5+lnifD+oGmtpfL5Q5t13CgVCrR3t7u0Oy2S7f8ZXJdbGys2SzaXV1dNtUqdXatYGKe4d+iy2soy9qBmkLggyv41x/5WPsP0PbQVRdoA0hAm930uRj+xz1SoS2x4e7EUu2/xe9qs8gGWp42QpwjOzsb7e3tvBfadfrz/eXn5+eQcxBiLCMjA0ePHsWmTZsgEonQ3d2Nq666CnfddZfRcGJruDyIXLRoEQCgqKgIc+bM4ZSb8PDwQGJiIhYvXmzVvvbu3Yu77roL48aNg0qlwmOPPYbZs2ejuLh4yCSmCA0NNepFFIlE7NBL/eNH+vCll+YLKLKysnD8+HGr5t76+/vD09OT3XdwcHC/U8Drn7icOXOGrZ+ko1AoTGbNTUtL69dzD1YKhcJi+nBn4/u7BLRD4Kzp9VcoFKivr+cE//p6enqgVCppeI8Njh7VlgPo7OzkBOq2kOl1IH5dVA2B1AeMTHvx5/1bxnG29fT0RFxcnMkM4vp1XA15e3tzyvEAbtbzNQzpfxcHBga6tmf4tXFA02nrt19jZVvH/31wBJD6sq92dQuGPQ8PD4vTVFz9m0xMi4yMxNq1dow84OHyX6knn3wSgDYT5JIlS/p1tc8wPe3mzZsRHh6OgoICTJkypV/tdBeGgY+1J5Xx8fGcejuJiYkoLy+3+Li6ujpERkbaXYjUXehOyIKDgxESEoLm5mbegE8qldrUg5uZmWl3mwICAtDe3s45OTHsMS0wKOprSmxsrMnkOUNdfX29Vds58wKL/pDVnJwc9rZ+EGkqwKirq2OHWjc0NPDuv6mpCU1NTQgLC7MqcdNwp19r07C31xoaDYPUx38CIMbDf/7Ut0IvsAjx7RuJoLuIFx4eblcZqrS0NBQVFXGWUZFt19LvSRkxYoTrGtLTYlsAaa0HzgK+9s1XJ8QSezK7E+fbvHkzfH19cc0113CWf/755+jp6cHSpUtt2p/Lg0gdWxtuDd3QInMJQ+RyOWeomK6WjUqlcnl3uu759efTqFQqo/vWtDMwMJCt+adUKuHn52fVPJ3z589DoVCgrq4O6enp/aqvN5B0x0T3f1tbG1QqFSQSCby8vBAbGwuGYVz6HkskEqhUKgiFQrYdMpnMpvlT4eHhbDDsyNdiePzcka3zzKKiopz2epRKJac9uudRq9WcoJKvRJGptNp883hra2vtGnIy3JSWlvK+H9bSBpBcGnkPNHJtgpyrxkRx9u/l5cX7fW0tw+91QBvEuPPfnyWD4TvEnMrKSvY9GejXoFQqIVb3QvKs+aHYytt/BUJTISjeDnj4QPwZt3aiJv5iqG/8GlB2Q/jryxD99jJUl70GJuc63RM56RW41mD/7A0F/v7+nN82W98Ld3sPHZFF3x2sX78eb775ptHy8PBw3H777TbHYgLGhZc7dclfQkNDERQUZLanq6WlxaZ9MwyDK664Aq2trdi/f7/J7dasWcPbrfvOO+84dC5Nf+jXoOMbNmdvHR1Lte0MCQQC116R7Ye6ujp0dXUhKCjI7Dj+gaRrE6BNaiMSiSCXy23qyUhOTh62V/xs/fyOGDHCab3pTU1N7Hw3c3+PXV1daGxsRGRkpMVETykpKaitrTUqUUJ1sywz/GxYOmavFwvhKwaWpmlQ1Q28cNT4+qq8TrvPFSNVCDQYCa//2bL1c6l7vOGc3sDAQLf5DRqO9N9Hm/7mGAa5lZvR6RmNc+HW5XPQF9pZjEln1/OuOxm5CKeirkJ4x1GohR5o9k032uaKwpsBABoI8e2YLTY/PyGOoMtpojPYf7eampqwYsUKVFZW9nvakit5enri5MmTSExM5CwvLy/HqFGjTCaHM8WlPZEbN25kh+Bt3LjRoSd4d999N44ePYoDBw6Y3W7VqlW4//6+1NTV1dXIyMjAjBkzEBNjYiL6AFEqldi1axeuvvpqNktVTk4OysrK2B5TALz1Na2hX2BeKpVanbxDIBBgzJgxdj3nQNEdu1mzZkEikeDs2bPo6OhAfHy825yY6R9/iUSC7OxsnDt3zqZaqPa+95YYHj93pH/8rOGsYwVos0jrhqLm5eVZdfwstT8vLw81NTVGGeqEQiFbh7O0tBTt7e3IyMhwfeIPN2J4bPPy8qDRMBAKub8xHxyqwNPf99XhjOqKxvfH+o73k3kqLFk4CwKhCM9+qERuTADiQ7iJsxISEjgXpjo6OqwKJPUvCObl5Rm12d/ff1CfeA2G7xBTVCoVp6SHVd8dsg5IXkrmLBo1+xYw0Tb8VqpkkDx/M+8q5YPnMcLDB9rLuPNN7yJ5CwRt56GZcJeZrYa2wfzZGyoYhkFhoTaTta+vr805G9ztPbQ1u7+7Cg8Px9GjR42CyCNHjtjVweLSIFK/23TZsmUO2+8999yDb775Bvv27bN4xUAqlXKybOqSmIjFYrf44ALa2jnR0dEQCoUQiURITU1lk0YA9tfSueiii9jAUSqVWj3/DtAmrRgM2V8lEgkkEgnEYjHEYjE8PDzc5n3VT5zBMAwUCgV6e3utTqjh5eXl9NeiO37uyPA4icVi3iEnYrEYubm5Tm1LeHg4Wlpa4OnpyTle5o6fufc5MDAQEokEIpGIdzuZTAY/Pz90d3dDLBbj9OnTg+LvcaCIxWKoNQye/u4E/jrfBo/wegiEInxz9yTkxAbinf3n8Mz3JUaP0w8g/zY+FsGicvY9vDKPv9yS7r3SCQkJsWq+eWJiItt7LZFIEBwcjI6ODohEIqjVavj4+Ljt354t3Pk7xJSKigrO353F9rdVAi9nGS0Wy9sA3WM7aoD/XAp01mrv+8cC95/Qe9Lfgfdm8+//iVZIrB1xkq2tm2i6sNDwMRg/e0OJ7m9IJpPZ/T64y3s4VBKdXXfddfjHP/4BPz8/NlfM3r17ce+99+K6666z8GhjbnNU+Ort6bMmmQTDMLjnnnvw1VdfYc+ePXZn5HNHhiemjsJXpgLQBii2dmu7K41Gw14ccOehnydPnrS4TXZ2NiQSiVFCnuHIx8eHM9QzJiaGMwcjLy8PHR0dA3KcfHx8kJWVZdPfprnef91VQlNJg/iCxsrKSnR1dWHUqFG8jxlOQkJCMHHN1+x9RUMZpJEpuPw1y3Ww1L0dyI4LxtrLMrBjR7nF7RUKhcleYF1AaGpdTk4OOwInJSUFCoUCzc3NqK2tNcrWSgaARgP89S7aFMmAV6Dl7dUq4GkzV+/3vwikzQY+uUFbZkNfR5XFLKrKVXWQSAdHHgJCTDGXl4QMrGeeeQbnz5/nlFTUaDS4+eabsW7dOpv35zZBZGJiotnhrKZ+iPXddddd+Pjjj/H111/Dz8+PHQYWEBAwaBLC2MqRBciTk5Nx7tw5q7eXy+Umg1B3UlNTw962p16kswQFBaG1tdXidgKBgM3UqMvOq0uSNJzpf1+kpaXB29ubE0QKBIIBDbRt/VsICAgwmY1VP9urtXT7qqmpQXR0tM2P74+2tjZ4eHjw1khta2tDZ2cnYmJiBuwizuNfFlq13YvX5OLq/Fh8+mcFHv7yGBiVEm9eHo/IQPNDg/WHovJdodaV/gkKCjJb4kX/ooNAIIBUKmXfR8O5sMTJ5J3AcxdGLtWogdv3APILWX4/WwoUb+/bdtn3wJYFlvdZ+bv15Tb0qMfdjt09GbhU6DanaITYLDMzEy0tLQP+e0RM8/DwwKeffoqnn34aR44cgZeXF7Kzs22aRqXPbb6hdGOndZRKJQoLC7FhwwY8++yzVu1j06ZNAIBp06Zxlm/evNmhw2XdiSODiaCgICQmJsLLywvNzc0WeyJLSkrYuVnuTD/dvzsNSUhISLAYRHp5eSEtLQ2tra0mawgOV97e3ux76+fnxymJ4C7zXs2Jjo42GURaw1RwUltbi4iICLsCUXt0d3ezSWHy8/Mhk8kgFArh4eEBlUrFrmttbUV2djYEAgFUKhUUCgVv0Nkf55u7MeVfv0BRb35kCwD8tXomQi+U6VgyLh6LxsSgp7ODvZBmKitgXFwcPDw82OPPV282LS0N7e3tCA4OhlAoNHqfzb031lwwJQ6klAHPRhgvL98P/PS49na0wftlLoAceyvw13um109+QNtDacqTbdCoVJDt2GF6G0IGAU9PTwog3VRaWppDaou7zRk135ylsWPHIjo6Gi+88AKuuuoqi/sYTnW1Ro4cic7OToefLOsm1uoHXqa4y8mORqMBwzAmT8z0e6zcpc2A9kQyODjYZObhyMhIREZGQiQSWSzsOxzFxMRAJBKxwbX++xwRwXNS6GYMP69+fn7o7OyEj48Pu0wikZgMZnTz6ficO3cOqampDmmnIaVSyelB029Hc3MzOx8wPz+fM1xXqVSitLQUKSkpOHPmDHp6epCZmWlyKGhraysCAwOtSrjW2CnHuGd3AwDUXc2cddv+byK2/lGJby7kRfh4xUW4OMX4e1MqFqFB73tPv06g/ms0nFfN1z6JRMJ+NxteuBIIBE6fo0vMYBiA0QBbrwfO/Gh6O10AaQ2hBFj+ExBzIQEPXxB5649A/ATt7XErgFfzAKXekOX7ioEA1ybzI4QMPffffz+efvpp+Pj4cBKJ8tmwYYNN+3abINKUtLQ0/Pnnn65uhtvx9fV1avH0sLAwu4pmu4KuF3vMmDG8w+X0A2KZTDZg7bJGUlISEhISjHriAbg8O7C7EwqFRlc5Y2NjoVKpBmWm0vj4eNTW1nKyQsbHxxuVftDR1cHlo5sD7GhlZWVoaWlBcnIyG+DpB1H6CWUYhjGa09ne3o7q6mp2vl97ezvve3XkyBE2SZK5hEEMw2DGS3txrqlv6Ke6uw0AEOAlxvu3jIdYJMTNExNwW2Qq0iJ9IRXzX2zSaDQmA3P91yEQCNhAXywWW+zx1T8+kZGR9HftKu3VwOdLgSoHnk/E5AO3/gSIDE6l0uYBp3/ou/+3z/oCSADwjwIeOgdoVMBvrwL5ywB/6rEhhDheYWEhezH68OHDJi/M2lMhw22CSMOTHoZhUFtbizVr1jjtijoxzdoPE8MwTqu9Z+3z63R1dVmcI+qOvdVCoRCBgYGcE9jBnNrflQZDD6Q+Dw8PKBQKiMVieHp6GiUDM+zFysrKwvHjxweyiRy6XnPdkM+kpCTU1tbybqtWq3mHa+uXLKmqquJ9z/Sz7PJ9xzAMgx9P1OOO/xpnlL5+XBxumMCd3yEQCBAi7IZUzD8/TaFQ4NixY5xl+j3A+heidKMZrM2Gqz/6wV0KZw8rJd8Bn95gfpt/FAHB2r899RMmfkPiLtLOcQSA6auB8beZTr5z/Vbg+39qH5N9DcA3F1hyIU/D9EctvgRCCLHXL7/8wt7es2ePQ/ftNkEk37AlhmEQFxeHTz75xEWtGt6Cg4Mhl8vNJng4cuQIfHx8BizQb29vx9mzZ+Hp6YnMzExOopz6+nqLQWRUVJSzm2iXmJgYThA53DOvDhcJCQkoLy+3elK7uyWy0i8mbYiv3AofmUzG6Y007HmtqqpCXJy2vEZ7rxLbC6vx5DcnYOjQqhmIDPA0WaqotrbW5PwcvlEXpoLjzs5Om7IN6r9nfPMniRNoNMCh14GfVpvfTigGHm8C9M49mnu5Fxqj/QTAbb9oh6p21ALlB4DMRYDITCZmgQBYaNuwMEIIcSbdKK2ioiJkZRmXJLKH2wSR+pEyoO2dCQsLQ0pKilslQxlOdL0iuiFsfNRqNTo6OtDb2+vUDLgtLS2cE1aZTAaGYXDq1Cl2mTWJZ9y1xIenpydiY2NRVVXl6qaQAeTv74+cnByT6zs7O63aT35+Po4dO8aZx1dQUIC8vDyHjRSwtdhyc3Oz5Y2gLW0zevRolJdrazIaDiltaGjAl7+ewPM7T8EjYoTR65mXFYlNN/L3Co4aNQolJcb1IA3xHSP9C1T6JY9sTWamv29zgSxxgD3rgT3PmV7/YCngYz6PQL06CID29y522buIyJwEBFzI2uofBeRc46DGEkLIwBGLxUhISHBobhC3ic6mTp3q6iYQE6zpUbC218FefD0eDQ0NnAyyKpUK5eXliIiIYC88uOPwVVMiIiIQEhJCF00Iy5p5z+Hh4QC0nx/DHrWWlhY2WVZ/MAzDGYZqDWu3V6vVvL2HDMNgw67T+OVUY9+2XS0Q+2lfz5KxcVi/OJsTpJ0+fZq9HRMTY3Rhq6Ojg3e0gpeXl9HQW/3vNP3vGVvr9No6hJUuJtnpj/+YDiCzrwEWv2PVbvzu/gXNZ/4AgkdAmJgEBFBSM0LI0LB69WqsWrUK//3vfx1Sv9Ntzla/+eYbq7e9/PLLndgSYsjLy4szZ3X06NEoKiribNPT0wM/P78BbZdh76iup6S5uZnt3bGmDqM7oQCS6NMPWMaMGQMAyMvLw+HDh9nlDQ0NiIuL4x3q2tPTY1cQWVRUBLVajVGjRsHb29tiL2RERAQiIyPR0NBgchioLWRKNa5+86DRcnV3K8R+IShdNx8iIbf3sL29ndNzK5VK2VqhuiREpq7A8h07tVqN2tpao+RAtg5JtbWMiyvnmLN0tQ1nPwtcfLdr22KOSg7sfIQ/G+qy74HES2zepUjiAYRqU987M3kdIYQMtFdeeQVnz55FdHQ0EhISONngAXDOLazhNmesixYt4hRV1zFcJhAI3KpMw3BgeDWfLxuhqQQZjmCql1OX4dGcmpoaRzeHkAHDV0pCIBAgKiqKDdZ0PWt8gZAuwLRFT08P+x1bUlKCnJwco0AqNTUV58+fZ4fPxsZqh/tFR0ebDCJzcnJw9OhRzusx/L6Xq9S45+NC1LRzsyjHBXmxQ1ZTU1M5AWRNTQ16e3uNhsHqegATEhLY521ubuYd9q4/dFVfd3c3qqurORd3bL3Qo98Tac2Qf5cl32k6A7w2lrvsp8fcK4jsrANeGml+m7sLgFD7E5PpB/3OnKJBCCEDzVSsZS+3CSJ/+uknPPzww1i3bh0mTpwIgUCA3377DatXr8a6deswa9YsVzdx2NL/sLkiU+6RI0dsfowum6JarWZPvjMzMx3aLkKcTSQSITU11aiUhv6FFV2Q6OnpiREjRkCj0RjNH7al5InhHEL9wA/oK6WTnp6O9vZ2q4bExMTEcAJiqVSKzMxMHD58GAqVGk99V4yiSm7JEqFECo1SjnduHovIgL72nzlzBrm5uRCLxZDJZCaDVm9vb+1+9OZBm7ogdf78eYuvwV76tT4HerSGVcwFZqEWAraBotEAT1mY8x46Erj7j4FpDyGEDCI9PT148MEHsX37diiVSsyYMQOvvvpqv2vNu00QuXLlSrz55pu45JK+4Sdz5syBt7c3br/9dquSIxDn0A8idSdmA8Xeq/K6uVFqtZrtOXC3zJaEWINvDp9+b5h+gKhL+qIfRJ44ccJkDVV76PYjkUis/gEKCQmBSq3BKwXdqKhtxtiMJBT/74DZoTOfPXw1PNvPs4/XT9SjUqkgFoshl8t5HyuRSNihiPrBtyuyHkdHR+N8eTmgUVtVI9JST6dSqYRYLLZv2KtKAXxyPXB2t3XbB7iopqVSBjBqYJ0VSYgeOAOIPEyX29DDMAxUKpXN81oJIWQwe/LJJ7FlyxbccMMN8PLywscff4z/+7//w+eff96v/bpNEFlaWsr7Ax8QEMApYE1cSzeUNSIiwmiIm609Hpao1WqjXhBb8A2NJmQo0A0bNZzPYIpKpbJqLl9/5zOWNnbhiveOQ93dhm/vnqSdfqBhkPLYDxAIdcPgPVBWoJ1jKfYPg6pDmzjHIzwJioYyPDA7DdNGhiM/JRRAX5CqH0TK5XJ4enqanNqgn/FWP3gesDnHim6g4H1gzA0IKfkA3V8+CX+pAELxa9oAKX0+0FAC1B4B1Aptb+Dh94HY8Qhe8gmqqv4CInONdtvT04OSkhJ4enoiIyMDDMOYvzig6O4LxC5/DfjGwtDUu/8CQlOB49uAL27RBp3WUqsAkRgo/R8QkgL42FFOqbkUeDXP/DY3fgkkX8pbe5FhGGg0Gs6UC7Vazd4/ceIE5HI5O9eXEEKGg23btuHdd9/FddddBwC44YYbMGnSJM73oz3cJogcN24cVq5cif/+979sLb+6ujr885//xPjx413cuuFN/0RVF4hFR0cbBZEnTpxAVlaWw3r8GhsbjZb5+/tDIpFYVT7A1DwnQoYCa4vd28LSHGL9njSZUo31P5zElt/KAQBpEb44Xd8FkW8w1N1tuOy1XyHy1vaiiv3Defcn9PKHUNELgdgD5/91OSorK9HQ0ICUFPNz2s6ePYvExESjC4zBwcG8wbK/vz86OjpQUVGBsDD7s22mpaVZ3ohh+gK3H1dBACAh8ELA88092v9/eJD/sVV/QPBCElCnAUZdBsWYPM7r0SUTk8lkbC+uyYBo6/XAqR19980FkPccBkJG9N0XX7gYqOrlDiW97wTgEw6IL7Sp9gjw1hT+fT5UYfr5dHpbgZYybQ3GL28Djn1mettpjwJTH+LUdNSn0WhQWFjI3s/Pz2ez/mZmZuLEib7aoiUlJcjOzqa6nYSQYaGyshKTJ09m748fPx5isRg1NTU2503Q5zZB5HvvvYcrr7wSCQkJiI+PBwBUVFQgLS0NX331lYtbN7zxTcA1dfW7rq7O6sLplhhmhMzMzGR7Otva2iwmWNLNiyRkuNNoNOwJdUpKilXDOg2zwKrUGqzfU4tj1SdR2thttP3peu3fm0AghDSSPwjccss4jIz0g1AggFypQVSgJ+o7ZAj01p7Mx8XFWf2DxjdCRVfb1pB+dumKigq0t7ezSYH0ey0FAgFGjRqF4uJi3v2Yzdb581PA/pesaLmVSr5FTU0NEhMT2UWcC2NKGfDeHJRLgIxX2wFdT6818wf/eRpQywGBiH/IqujCcM/qAu6+Nlo/r1zyr3hcAUCV+xOQeJF24eEPLfeG6kj9ges/ARInWbW5LgMvH/0AUqexsdGq4cWEEDLYqdVqo4tmYrG43+X53CaITElJwdGjR7F7926UlJSAYRhkZGRg5syZNAzRxby8vCAWi626atvU1OSwIDIoKIhTokN/qKyPjw97Yqifwl9fY2MjRo50k8QQhAyg+Ph4VFT09QTpn0SfPXsWGRkZFjNPCgQC1Lb14rYPtcGnQCiER3iy3W36/I6JGJdonIQnNsi6YYUjR47EqVOn7H5+HcMRDvoBI8MwZo+Lyd8ipcxhAaRGd80uINZomFFjYyMg7wJ2PaEN8AD0KgG8Ph6450KtTUsB5A1fAn4WMmm3GNfltZd4y2zbHnDfCSAgtt/Payn7oH45GEIIGcoYhsGyZcs4IwVlMhnuuOMOzmjDbdu22bRflweR8+fPx9atWxEQEACBQIA//vgDd911F5sgorm5GZMnTzZ5ZZg4n1AoRE5OjlXBvCOKl+r4+PiYrPMYFRWFjo4OBAcHw9vb2+xVaMA1CTUIcZWwsDBOEGlI930aFBSE5GRuYNjUJcfXxW1Y/Pn3ULVrh6xLgqIglHLnX3579yXwlAgRF+yN6/9zCPOyIrEgJxr+nmJkr/kJU9PC8P6tjpuKYKlmn+43w1b6V2LDw/mH3Vr0rB3ljTKvAkbfAMjagLQ52pqHL4yARDfIo72KncPZ29uLsj9+AD66mX9fzWcBtbKvB1Hnmi1AwiSg6COg5Ftg6XeAhxVBe/oC00NuDUXmAFMeAH5+Grj6PWD7/wH1x6177AU1nRqIhUD4ugZAYntZjYqKCqOLA5bqnVGiNULIcLF06VKjZTfeeGO/9+vyIPLHH3/kZNh7/vnncf3117MnBCqVyiFXn0n/WNsb7Mh5iPpXknXzZHV8fX2RnZ0NiUQChUKBqqoqAMZD8HQc1TtKyGBh6m9B3xs7j+CLCm3m6w1XZ+Gdr4+jsLINkpBYCCWeEPmHQ+QbDMGF4CTQW4IPb70I2bHcizJf3ckdcli+foEDX0mflJQUnD171mj5yJEjrU4yZE5ISAgAbUDa1NRkfuOS74BPb+Bf90QL0N2kzTCqkgF+UUDdcSA8HWgtB3wjAF+DgFXqBzzRCoFeT2JbYx2ioqJQfK8V8zifDgWe0Lvo5h8DZF6pvX3Jfdp/1gqIAR48p22T2AOQdWjnK4ZnagNEsVS7b6leyZKMK7T/3/IDsN7MkOTF7wJfLtfeXtOOmpoaNqFTuB0BZEdHB+/8eUtaWlpMDn8GLF+0IISQwWLz5s1O2a/Lg0jDISeOKoBJXEM3V7E/2Z50dHOWAG0iH0O64bVSqRSjRo2CRCIxGexSSncy3AgEAs6ch265Cuebu3G0qh3//b2vl9IjLAECkQT3vLUTGqVMu/DC1/BbN+Vjalo4vDz6//fsCHy9RzExMRZP+IVCoVUXuHTfE0lJSQgKCsKBAwdMb8wXQF63VZt5FTAeMho3Tvt/ZLa5hgJznwfeewAA0PPaZCDaxLFPmgKU7eMu0+89jMxBv/iE9N329AfGrdDeTpho/nGe/sAdv0LJCLHjjzOYP28uJEJBXzIeAMi+mr2pnxFYV7rFGmVlZfDz8+tXjc+TJ09i5MiRvL8b/Z0rRAghQ53Lg0gy9JSUlCArK6vf+9H9iFuTTdFcunZLc78IGaoKy5uw6ivzQwtVrXUQ+QWzAeTYhEC8e99shAf6mX2cK3h6eiIlJQUVFRVQKBRISEiwqlalSCSyKojUXfwSCoXw8zPz+ku+41+uCyD7I+daAA/wrxu7XJvRNHkqED0aOLEdOLCxb/2f7/TdDrMik6yzRGYBSiWAM4BACIitu4jX0tKC8PBwqFQq9Pb28r4HKpUKR44cYbe3llQqhb+/P9ra2tj6w93d3Th8+DBycnKMLjTaW6OYEEKGC5cHkQKBwOgqICXSGRwyMzPR2toKjUaDuro6drmpAuD2svXzMGrUKBw7doy939vb69D2EOLu5Co16tplFgNIAHj/5lzc9N4fEAqA7XdOglAocMsAUicgIADZ2WZ683j4+flZFXCYq7nIWWeqF9IRvLnzyjvlF7qFL7kPyFzE3TZzEdB6HkzLduPvybB0x7THiQx/K5qamhAUFIRjx46BYRgkJycjKIibKEgXQJri6+vLycwdFxcHLy8vNiCNiooyqj989OhRo5I5hlMoCCGEcLk8iDTMGGSYLcjRAQlxHE9PT0RFRfW7QLkpuqQ6ts6zpCLSZLhiGAZLN/+JfaeN54hNHxmG5267HE3njeeYf3fPJQPRPJeJiYlhgywPDw+rv7MiIyMBaIe5pqammt4wYxEwcl5/m9nnsn8D394LADgdMAWY83+AXyS7Oj4+HgqFQnvx7pJ7ofl6O0SG19oyFjmuPU6gUChw/Dj3Ikdvby8nwGttbeUEkd3dxqVl9FlT+9HaqQ2OTBJHCBl+3njjDbzwwguora1FZmYmXn75ZU6tRn3btm3Dpk2bUFRUBLlcjszMTKxZswZz5sxht9myZQtuueUWo8f29vZyqhcMJJcHkYYZg/iyBd18s4mMdMQtREREcIqUOyIhga6mHaC9sEAI6bPi/T+xu6QBAPD3qcm4Jj8OMzfs5d32oqRgPL4wAwCQEOqLJgtTyEaNGuXQtroDDw8PTr1F3Rxr/e8ZvqDB19cXeXl53MDj7O6+21MfBqY/6vD2Ino0MG2V9vbIuUardUP8dSNAVPkrICp8t2+D5busy8LqQqYyb+szzLqtP+LFkDUBpE5GRoZRxveCggJkZvbVwTTXK00IIeZ8+umnWLlyJd544w1MmjQJb731FubNm4fi4mLEx8cbbb9v3z7MmjUL69atQ2BgIDZv3ozLLrsMv//+O8aMGcNu5+/vb5Rs1FUBJOAGQaSzMgaRgSMUCpGfn89m2dMfSuQIfEl1rGkTIUNFS7cCj247hp0njE+i39p7Dm/tPWe0/MoxMZgdEYhwP+4PzKhRo1BSUmLyuYZTT75+tlerhi9+uxIo0PvN0gV6DhYeHo4GGAePprRf9BDCL74DBedaAKEIebFj4c6TQjQaDZtR29J2+tra2kxua20ACZg+6SotLWVv07QaQoi9NmzYgOXLl2PFCm1Cspdffhk//vgjNm3ahOeee85o+5dffplzf926dfj666/x7bffcoJIgUDAjpBxB3SmTRzGnjTr1rAndb8uVT8hg5lKrcG0F35B3tO7eANIPm/dlI/y9QuwccloTgCZkpICQBsk5ufnG80Bk0qlRsuGOv3ELUaZX9urcEXhzRCcv5ChVd7JDSABwEmBhrmal/o9qjpSLy8oA5O0CWyEQqt6+VxFqVSisLDQ6u11pVbq6+tNbmNr9m1TAaL+qBe6EEkIMdTZ2YmOjg72H9+UO4VCgYKCAsyePZuzfPbs2fjtt9+seh6NRoPOzk6jETJdXV1ISEhAbGwsFi5caNN3qTO4vCeSDB2OKs/S2dnJuW/Pj7n+SQIVlSaDTUltB+b9e7/J9Z/fMRH58UFIfnQHAODNG/MxN8v46qSPjw87jywgIMBovX7pi+FYF08oFCIvLw+AQWDx13uQfKetqyj+7yL+Bz9mOqjpr46ODt7lubm5VpXA6OnpcYs5fWq1GuXl5QgPD2c/fxUVFRYexXX+/HlIJBKzPZfJyck2ty0rK8toTiYhhJiTkZHBuf/kk09izZo1nGVNTU1Qq9WIiOCWeYqIiDA7JF/fSy+9hO7ublx77bXssvT0dGzZsgXZ2dno6OjAv//9b0yaNAlHjhwxP2ffiSiIJA4TGhrKXi3WaDQ2B38Mw6CqqgoNDQ39bou/vz97m2/8OSHu6GhVGy5/7Vej5VKxEF/+38XIiuEGguXrF5jd38iRIyGTyUxeSNEfLjhc5x4L1ArgmXDtnSfbAEYDXAggzZI4bx6KqWRihgGk7iKBRqPhXMSrr69HbGys09pnrbKyMsTExKCjo4Pt5TY3JNUU3ZBjQzExMQgICLCrjJNUKkVWVhYEAgEnmzchhJhSXFyMmJgY9r65TgrDEQ8Mw1g1TH7r1q1Ys2YNvv76a4SHh7PLJ0yYgAkTJrD3J02ahLy8PLz66qt45ZVXbHkZDkNBJHEYf3//fgWRNTU1RgGk/lhwW+ifVNgzHJYQZ/vlZANu2fKnxe1+f3QGIvztC1gEAoHVJ9hDrri6Sg68lA706pX2uP8k4H9h7mPTWeA1g+G7+14AfnnW/H79ooBl3zu2rYZP4edn1cU0XV1LtVrtsJEgjmLL50ksFtv8+cvMzOx3QgkapUIIsYWfnx+nk4JPaGgoRCKRUa9jQ0ODUe+koU8//RTLly/H559/jpkzZ5rdVigUYty4cThz5ox1jXcCCiKJw+gnNuju7uYdPmcOXze/vfNS9B9HCRKIu2jvVWLBK/tR1Wq5dunRNbPh72nbXK/+GHLllJ4JN162ZT4wbgXwo4mMqgYB5Nejt2D+goWQQAX89Li2jEfKDCc0lovvuzM93bjuo67HUi6XQ6FQOL1dtjCclmBKUlIS/Pz80Nvbi9bWVkRGRlo1zNSZGQndYSgwIWRw8vDwQH5+Pnbt2oUrr7ySXb5r1y5cccUVJh+3detW3Hrrrdi6dSsWLDA/ygjQ9mwWFRXZXDfZkSiIJA6j/6PuiF6N/lwlFolEiIyMRHJyMiVIIC73VWEV3txzDqfqLZ9YH1o1A5EBrkvZPei1VwMbM/jXtZwzDiBDUoBm4+GSyvvPAr9cSIIg8QIWvOjghppmeOErMTGRd0SFrvfR2nk2A4mvpiNfoKsL2CQSCXuFPyEhAefPm65Fo58QyRmcvX9CyNB2//3346abbsLYsWMxceJEvP3226ioqMAdd9wBAFi1ahWqq6vxwQcfANAGkDfffDP+/e9/Y8KECex3upeXF3tRce3atZgwYQJSU1PR0dGBV155BUVFRXj99ddd8yJBQSRxE3wnF4YTmG3l6+trNsshIY6y9Y8KrNp2DOuuzEZuXADSwrzBMMCT3xbj4z/4E4I8fUUmbrgoAQIB9ZY7hErO3/toysgFwPUfa2+X7QfeX6i9vXw3EDcOUCod30YbZGRkoKGhAdHR0Sazj3p6evIGawPB0pQFvgRAzc3NVu07NDQUdXV1JnvHHZ1EIjs7mzMvkrJ7E0L6Y8mSJWhubsZTTz2F2tpaZGVlYceOHUhISAAA1NbWcpKMvfXWW1CpVLjrrrtw1113scuXLl2KLVu2ANDOJ7/99ttRV1eHgIAAjBkzBvv27cP48eMH9LXpoyCSOEVzc7NNP8SGtSVjY2OpB5G4lEqtgVgkRF27DD8cr8Xab/uKk29eNg7nm7ux80QdDp3rm3P36Ff6CTrEALgBZEygF55elIlLUsLgIXb951u/ZqSluRpuS9Gt7V0s2MK//olWYNNEoPFk37JV1YBULxtt0mRgTbvxY13Iy8uLPeEwxVUXH+rq6lBdXY3k5GQEBQXxbmOY7beoqMhoG1OPBbQZV/nqmTqjDI2HhwfS0tJw+vRpBAUF0UUdQki/3Xnnnbjzzjt51+kCQ509e/ZY3N/GjRuxceNGB7TMcSiIJE5hKrugodLSUiiVSk7AKZFI6EowcZlTdZ2Y8/I+s9tYkxBH313TR+DBOcZz2lzN29sbUVFRaG9vR3R0tKubYxuNBvjwCqDMxHu14mcgduyF27uBoq1AxuWAn/sUau4vXQ3FgdTR0YHq6moAwLlz50wGdYaJftRqNby9vdHT08MuMxcke3t7Gy1zZh1TPz+/YVcnlRBC+oOCSOIU1mYK1KV7108kkZOT44wmEQKGYfBVYTV+LmnAK9ePgUjY1+NQ296Lic/9z2HPFSJlsPvBGQjytb38wECKjo4ePAGkrB3oagR2/BM4t4e7LvMqYM46wDsYEBvMp5b6ARfdPmDNHMoMMwGqVCqralcaCgwMZLPLmqI/NzIsLMzm5yCEEOI8FEQSpzBVVqOlpQUdHR1GV6BramoAODfjHhm+TtV14uo3f0OnrC/h0/fHavHX6plY/v5fOFLZZvKxzyzKwrVj4+AhFuJgaTOu/88h7T6fmQupWISGDhk6ZCqkhGuH77X3KNHRK8PhA/+Dr5S+YvtNKQM+vQE4u9v0NvceBYLMD/0k/cdXS/Ts2bPo7u5GVFQU52IE34VE/bmd1iRfCwkJYX8b4uLi7GkyIYQQJ6EzHOJQQqHQ7FDWsrIyANrhrnxDmYZrwXPSfzKlGrd98BcW58Vi5/E67DxhOWPl2GeMA5PcuEBsv/NiAMZzziaOCMG5dfMh1OvBDPf3RLhe2agAbwm8B64yx9DV1QC8aCGByh0HgEjXpTd3V46YT3769GmoVCpOgrNTp04ZbadL7FNbW8sJIvmS4rS39807NZwHz0cgECAzM5O9TQghxH1QEEkcShdANjY2Ij4+3uR2ra2tNteRJINTl1zllB45pVqDsw1dmPfv/Zzl+8+YnieWFx+IsYnBeHvfOaN1W24Zh6lpYRZPVvUDSOIkf/wH2PEA/7r4icCy7wGh+aGQw5m1c9JNUSqVbJ3Hnp4edn6iNb2H7e3tEAgEqKysNLudtaNOLA15JYQQ4hoURBKXKS8vd3UTiBNpNAySH91htPz0M/Pszkxa1dqD2z8oQHFth9WPCfSW4KYJCbhpQgLC/T3BMAwniPzg1vGYkkbzrVyKYYA/3zEdOP7tcyBt9sC2aRDw9PQ0OXqDYRi7e+/0g1CZTAZPT082qDSnrKwMLS0tFrcD+l/CiRBCiGtREEmcpq2tzeY6jYmJiU5pCxlYcpUaI1fv5F2XtvoHlK9fYHEfSrUGJ2o6sOj1XyEVCyFX2da7cuSJ2QjgGVcqEAhQ9tx89jZxMN1cOL5jK+8CwABqJeB5YSTC4Q+A71by72vxu0DWYv59ESQnJ6O4uJh3XX+CSP3akxqNBpWVlVZlgrU2gATob48QQgY7CiKJ05SWlnJSpqvVarPbR0dHU2mPIeCyVw/gWLX5mntzX96HnSun8K6raevFE18fx+6SBnaZuQBSv3yGLpmHpRNUOoF1ILUKUHQCXkHAie3A50u1y59s6wv+9r8E/PyU9fu84g1gzA2ObumQ4+XlnMy/+mU4GIbpdykRDw8PKBSK/jaLEEKIG6EgkgwYvmLT+qKiogamIcQpZEo10h/n732cnBqKUF8pvirU1pc7WWc8NO7Rr47h498rLD5PyVNz4eUhglrDoL5DhujAvhNpCg4HiLwTqDgEfHS16W3WBtq2z+W7gLjx/WrWcKcfrFlbZomPfmIeRwSq2dnZKCgo6Pd+CCGEuA8KIgkh/cIwDFa8/xd+PtnAWf7Z3ydifFIwe7+wopUNIgHgq8Iq3PfpEYv7/+buSUiL8IOHSMhJaiMSCjgBJHESeRdQsAWoPASUfNv//aXMBGLHa/cpEAAd1cDc9RRAOkB8fDzOnj0LoH9BpDN6OGNiYlBdrf37p2kLhBAy+FEQSVxOLBYjNDTU1c0gdqhrl2HCcz8bLeeb8zgmPgiv/W0M7v64EABMBpDhflLs/udU+HtSnQyX0WiA4u3AF7c4bp+zngIm3dt3f9rDjts3AcCdMtDV1WXznHSdxsZG9rZSqeTdJiQkBM3NzVbvMzIyEpGRkXa1hxBCiPuhIJIMCMOr4vn5+dBoNA6pZ0YGVlVrDy55/heT6488aTqL5sKcaDaI1Dc6LhDJoT544ZpciKiExsAp/hr47Gbt7QfPARW/AZ/eaPlxo28AFr4MiCQXMqv+B4gZC8TmAyo58Ew4MOFOYO5zTm0+4XJU2aTAwEA2G2ttbS3vNtHR0VCpVJzaj4QQQoaPIRdE7tu3Dy+88AIKCgpQW1uLr776CosWLXJ1s4YNHx8fTmY/AKipqeEtPE0B5OBS2tiFGS/t5V0X5ifFoVUzrAoAp40Mw55TfT0d1mRqJXbqaQHO/ARU/gH89a75bV9INr3uvmJA4tX3T59AAFz09777YimwhgILV9Cvqdif4axSqZS93dvby7uNh4cHQkNDLQaRyclmPleEEEIGrSEXRHZ3dyM3Nxe33HILFi9e7OrmDHutra0mr2STweGXUw24ZfOfvOsmJofg6UVZSAn3tXp/W27Rzn177ocSXDyChjE7RVcjUPUn8Mn19u/jwXOAD2VLdnfR0dGoqamBh4cHZ7lE4rzh4LGxsQC0PZYZGRkmy4wA2lqWhBBChp4hF0TOmzcP8+bNc3Uzhi3Dq99tbW2uaQjpF4Zh0KMCUh//iXf9zpWTkR7p36/nWDVvVL8eP6yd2wN8cAUQNgq4+WvALwJQyoAvlwMnvzP/2MTJgE8YcGIbkHs9MPFu4M1J2nVLPgJGLXR684njREZGwsvLC76+3As5/QkiLfVi6g+bdVaZEUIIIe5tyAWRtpLL5Zyhlrp5ICqVymRCgYGie35Xt8MWYrEYKpWKvd/Q0GC0TWhoqNNf02A8dq7EMAz+PN8KhgFufO+vC0uNvx6OPzEDUol2yBwdW9Mc/fkTVP0B8fvzjVc0lgAvpYEJSoKgtYz3sepLn4Bm4j+MVyx6u+/2A2WAhw8gEAL0vgIYXN8hPj4+YBgGSqUSGo0GGo0GSqXS7ikDCoWC8z1uyPD3kW9b3TJ3+C0dbAbTZ88d0fEb/NztPTT3fTicCZj+TJxwcwKBwOKcyDVr1mDt2rVGy9955x3KGGoHtVqNsjL+k1mdoKAghITQMDl38XO1AN9UiEyuT/FncHeGGlSCcQAxDEY0/ICsmk/seniLTwqqA8fjfMh0qEVSyw8gQ8a5c+eg0WiQkJBgd29kV1cX6urqTK433LeurIifnx97IdbUtoQQMtg0NTVhxYoVqKysZIfzEwoijXoiq6urkZGRgbKyMsTExAxAK01TKpXYtWsXZs2aNah+hFtaWlBeXm5y/ZgxY5xeFH6wHruB0iVX4a/zrbjtQ+NMqdEBnqhplwEAfrxnApLD+zdsdTiy6vPHMBCc+BICeQcYoQRM3ARI3ppo1f41mVdBfekaSF7N6VuWewPUc54DxF6giL//But3SFFRETQaDTIzMzkJcmxh6Ts8IyODM9fx8OHDALQXCD08PFBfXw+VSoVDhw7h1ltvNRpqS8wbrJ89d0HHb/Bzt/ewuroaSUlJFEQaGPbDWaVSKeeHtqOjA4B2WKY7fHAB7dwWd2mLtcRi0x8twwQQzjQYj50jfX+0Fnd9fNjq7d+8MR9zsyKhUCjw/Y4fkBzuP6yPX38Zff4YRpsttaEE2P2k9TsadTlw6eNAWBoAQHjhHx6p0GZgDU7qW0YcarB9h0gkEqjV6n79hkkkErPf4QzDcPat21YikSAqKopTP1IoFA6q4+dOBttnz93Q8Rv83OU9NPd9OJzRUSEOV1VV5eomDEsKlQafF1SitVuBc03d2Ha42qrHLciOwovX5MLLo29Iq0AgAJVrtIGyF6g9CsSOBYQ8Q4PP7AaObAWOf2H9Pm/9EYifYH4bzwDtP0Ls0Nvbi7KyMkRHRyMwMJBdbmmAkmHPYnR0NBoaGhATEzOgFwkJIYS4zpALIru6utj5GQBQVlaGoqIiBAcHIz4+3oUtIwAQHBzs6iYMKdVtvdhxtBa/l7Vgd0m91Y8bnxSMT2+f4PRhxYOaogfw8NYGiI2ngLenapenLwSu2QJ01WvLaBz5FDj9A/exdxdCouqC6L2ZQG0R//6jcoH4iUDreaD+BDD2FmDccgoKyYApKytDb28vSktLERkZibq6OgQEBLBBIl/dX8C4xm9UVBSioqLY+2PGjMGff2rLAlGJD0IIGZqGXBD5119/Yfr06ez9+++/HwCwdOlSbNmyxUWtGl4EAgHvlezs7Gy6St1PDMNg0eu/4kiVdcXcrx8fjyXj4iARCZAZTcGJVX57Ffhpten1J78DnjafdEvy2hjw5FIFInOAMTcCIy4FQlP71UxC+KjVagCWexMBbU+kji6RTnt7O9rbtd8vCoXCrjYIhULk5uaiurra7gyxhBBC3NuQCyKnTZtm1Y8ncR5Tx58CSPOOVbXjiW+O46YJCbgqjztxe8exWtz5kem5jcmhPuiUq9DYKcf4pGCE+Hhg0435zm6ydRjGPRK9dDcBPz4KHP1Ue/+ew0DICO1ttUrbm/jpjc557ms/ADKucM6+CeFRV1eHpKSkfu3D29ubDSgB7YVAa4NCkUgEkch01mdCCCGD25ALIgkZjCat/x+q27S9AoUVbbj/syM49cxc/K+kAf9nJngEgFXz0vH3qSMGopm2YRhgbaD29rRVQNFHwIQ7gQn/55znk3cBux4HMq/UJpv5fKl2eUAc0F5pvP2redr/R1wKVP4JKDqNtwG0cxMDYgH/GOCvd4Hv/6ldvnw3EJMHfHQNUPozcMcBoLMe+GgxAODgiAcwdsnDkNDFE+ICLS0t/Q4iDQNGuhBICCFEh4JIQlxs3Y4SNoDUN3L1Tt7tP719Ai5K1tbZ1GgYCN0xA053E/CCXmC75znt/zsfAdqrgDnP2r9vlQLY9y9g3wv86/96j3ufL4DUV/q/vtsRWcCMJ4G02fzbjlsBjJgBBCYAuhPsm7b1rY/MBta0Q6lUomHHDvfogSWkH7Kzs3Hs2DHExcW5uimEEELcCAWRhLjIvtONuPm9P6za9h+XpuDuS1PhIeb2DLhdAFnxO/CeiQBM5+BrQM612sQy1uisB6R+wM9rgd/ftL9tiZOBpd8Cva3Avwx6aG74EkieBois+EoM7l/vDiGDhUAggIeHB/Lz3WRoPCGEELdBQSRxOKFQCI1GAwAYOXIkGhoaEB4e7uJWuZfSxi5OAJkXH4jP77gYKo2G0wMZG+SF7++ZjABv19dJMquzHngpzfrt35oCrDGTHOjcXuCDy21rQ2Q2UHes777+nEd93sHA3PWAWgmEpgFx47XLCBliGIYxysCsv0wqlUIul5t8fGeniSHehBBChj0KIonDBQUFscWmfX19jWqKDVcaDYPi2g4sfPWA0bptd04CAIiEIpSvXzDQTbOfRt03J9DQ402ASC/4LdoKbL+j775aqV3PMNp/Ox8B/njLuue9/lOg8SRw7HNgyX+5vYPWJPJx1rxMQtyISqXiFOpuampCZWUlUlNT4evra7HEj1KpdHYTCSGEDFIURBKHo5TuXG09Cox+apfJ9TdNSBjA1vSTRg3s/Rewd73pbaY9Ckx72Hh59tXA7ie19RUBi2UyODx8gTnrgPylfctGzgUuWWm8Lc1DJITX+fPnAQCnTp1Cfn4+ZDKZi1tECCFksKIgkjhceHg4GhsbERgY6OqmuFRduwwTnuPpobvgz8dmQqnWICpgEBTjPvEV8Pky89ss36UdGmqKSAI8cBpYY0W9yiUfaYeaBiUCYsoISYg9TPU0isXan34PDw9OLUgfHx90d3cPSNsIIYQMbhREEofz9PTE6NGjh22NsD2nGrBs858m13+04iJMSrGhF86FBGd+BD67wfQGXkHAjV8CMf1IvCGSAtNXAXETgPgJ1JNIiIP09PTA39/faLlKpQLArekbHh6O2NhYqFQqHD16dMDaSAghZHCiIJI4xXALIBUqDe74bwH+d7KBd/2/rxuN2RmREAoBqdhNj41Krv23/0VIfv03rgCAQp7tvIKA+08CEjt7UB84A7x+EdDbor3/OP8xI4T0z5kzZ0xmVlUoFGwQmZycjKCgIACARCJBVlYWGhoaqKwHIYQQkyiIJMROag2DEY/uMLvN+quycd34+AFqkZ1O7gA+ud78NuGZwP/96pheQt9w4OEyQNENiGioKiGuoFQq2R5JLy8vzjqpVEoBJCGEELMoiCQEQK9CjYvX/4y7pqdgxeRki9t/+mcFHv7ymMn1M0eF49L0CPcNIHvbgPrjwBbzmWAZ3wgI/nnKOUNMPXwcv09CCC/DJDp1dXXsbUtZWgkhhBBDFESSYU+h0mDUE9rajM98XwIPsRA3T0zEcztKsOdUI3aunAyBQIDKlh788/Mj+KOshXc/r/8tD5/8WYHXb8iDv6cb1HXsagReTLHtMYs2AbnXQ9lchv27d2Dy4r9DQieYhAxa7e3tCAgIQFlZGWd5W1sbe5uCSEIIIbaiIJIMa3KVGiNX7+Qse+LrE3ji6xPs/SVvH8LRqjbIlBqjx18/Pg7rrsxmT8IW5EQ5t8Gm9LQA39wDnPzO9scGJQI3f639XycgDp1eNJyNkMGuvr4eAQEB6OnpMbmNfoIdQgghxBoURJJhS6HSGAWQfEz1PJY9N981V/CVMqDuKPDuLPv3ETYKuPMgZUIlZIjTlfMwR6lUQiqVDkBrCCGEDBUURJJhK231D+ztlTNT0SVT4Z0DZSa3v3dGKm6YEI8DZ5pw5ZgYxwaQDAM8FQIwau391Q2AWO+kTqMBzu4Cij4Cir+2fr93/wUEXpiXKaaTREKGG2vqPhom1iGEEEIsoSCSDBuVLT0I95firo8OY3cJt6zEyplpUKo18POUYOPu0/jijom4+s2D7Ppja2bD78I8x6vyYh3bMEU3sC6au+yZcOAfRUDTGeDjayzv464/tOU5GkqAUZdps56K6M+bkOFOoVC4ugmEEEKGIDrLJMNCwflWLN70G++6sufmAwAkIiHunZmKe2emAgAOPz4LJ2racUlKqHOGrTIM8Oc7wI4H+Ne/Mpp/+cX/AAJigdTZwOH3gckPAFJf7bqoHMe3kxAyqKnVarPrhULhALWEEELIUEFBJBly5Co1oGGgYYB1P5zC5t/Om9z23DrT8xqDfTwwOTXMOY1Uq4CnQ4yXx+QD1QXGy9PmARlXALnXcecxzlzjnPYRQoaMqqoqk+syMzMpOyshhBCbURBJ3BrDMBZPcB74/Ai+KOA7SRID4A8gl05MwGMLMiAUDuDJk1oFtJwDXh9nvO5vnwNps7W3P7u5b97j2OXA3OdoPiMhxG5NTU0m11FCHUIIIfagIJK4pf1nGnHTu38AAL69+xJkxwYYbVPR3IMpL/xi9T4DvSV4cM5IXDcuHqKBDB7P7QU+uNz8NroAEgCu/cC57SGEEAAxMQ5OEEYIIWTYoCCSuJ1fTjbgli1/svfv/bQQ87OiEBfshU/+rERhRZvV+5qaFooXrxmNML8BvtquUQOf3gic2mF6m2mrgO5GIP+WgWsXIWRIS01NRU9PD6qrqy1uGxbmpOH6hBBChjwKIonLtPcqsf9MIyYkh6CuXYaFrx7g3e5cYzde++Wsxf39uHIKRkb6AdDWPduxYwfmz8+DRCJxaLtNUimA5rPAB1cA3Q2mt7v1RyDuIqrRSAhxOH9/f/j7+5sMIr29vdHT0wMAEIlEA9k0QgghQwgFkcQl7v+sCNsOW75Sbo3y9Qscsh+0VwP+0bYFd7ueBIo+Nh80XvwPYPpjgMRT20MppBM3QohrxMbGora2FsHBwa5uCiGEDFlvvPEGXnjhBdTW1iIzMxMvv/wyJk+ezLvttm3bsGnTJhQVFUEulyMzMxNr1qzBnDlzONt9+eWXePzxx1FaWooRI0bg2WefxZVXXjkQL4cXBZHEqRjm/9k77zgpyvuPf6bs7vXCVY5ywAEigoJgAaxRULEbI0GDGiFqMIlKyk+iRtQEjbGgiTUaWyISFVssiIUmWOhIP7jj4Hrvt7tTfn/s7e7MTtmZ3dl6z/v14sXtzDPPPPPMM8/zfJ/v9/l+RfS5Bby8sQKPfLrf8HXf/fE8PLJqv8JhzkNXTcT5xxch1c4ghaXBMha4phdF4P4c/+/f7gcyiz1/CwKg5v6+8YC6g5xA7muTC6VEgCQQCFEgLy8Pzc3Nvt8sy4LjODAMg7Fjx8awZAQCgZDcrFixAnfccQeeeeYZzJgxA88//zwuuugi7NmzB8OHD1ekX7duHWbOnImlS5ciJycHL7/8Mi699FJ8++23mDx5MgBg06ZNmDNnDh588EFceeWVePfdd3HNNddgw4YNOO2006L9iACIEEmIIFc8/TW2H20znH7plRPx72+O4KUbp6IwKwWP/uQkZDhYTBiSjaunDIUgiNZ7U3V2AQ8NkR974Rzg3D8CH/za8/uPNYA9HajZDrz/K6B+l36eM2737HNMzSEmqwQCISakpaXJhEiO4wCQmJAEAoEQaR5//HHMnz8fCxYsAAAsW7YMq1atwrPPPouHHnpIkX7ZsmWy30uXLsX777+PDz/80CdELlu2DDNnzsTixYsBAIsXL8batWuxbNkyLF++PLIPpAERIgmW09bjwqQHVgdNp2aGeu1p8hWaJZed4PvbcgGysw547DiV47V+ARIAlpbo53PDh0DuCCB7GNDbCqQRMzECgRBbRFGMdREIBAIhqejs7ERHR4fvt8PhUIRJcrlc2LJlC+666y7Z8VmzZmHjxo2G7iMIAjo7O2XbDjZt2oQ777xTlu6CCy5QCKDRhAiRBMv55b+3qh5/5McnYtzgTIwpzESqPcpmnTwHPDYWyCgGepoAxg60H/Wfn/gTYNdb5vK8txlgAj4hIkASCIQ4wOl0qh4nIT0IBAIhNMaPHy/7fd9992HJkiWyY01NTeB5HkVFRbLjRUVFqKurM3Sfxx57DN3d3bjmmmt8x+rq6sLKMxIQIZJgOZdPKsGmwx4zqid/OgllBRkozUtDZooJL6mtR4AnT/T8ffsOj6ZPDQ1tog3A5QCwLeBET7MiLQDgxy8CM+4AnpuhXaZLnwLGXQIc+AQ46Vr1vZIEAoFAIBAIhKRjz549GDLEvwUqUAspJXDBThRFQ4t4y5cvx5IlS/D++++jsLDQkjwjBREiCZZTmOX5qE4oycLlk4YESa1C1bfAv2b5f6/4GXDzWoCiAd4FtFZ6hMGXL7KmwEvaPf8XTwDurgdqtgLDTgc+/A2w7XXgtF8CFz3sTz/5Z9bcl0AgECKEN4wHgUAgEKwhMzMTWVlZumny8/PBMIxCQ9jQ0KDQJAayYsUKzJ8/H2+99RbOP/982bni4uKQ8owkRIgkWMqmQ8246ZXNAIDdNR3aCUUR+PY54NO7gKv+CbApwH/nqaet2wU8YLGZqCMLmPNvYNTZ8uO2FKB0uufvy/8BXPZ34hyHQCAkHN3d3arHiTkrgUAgRA673Y4pU6Zg9erVsvAbq1evxuWXX6553fLly3HTTTdh+fLluPhipc+QadOmYfXq1bJ9kZ999hmmT59u7QOYgAiRBEuZ+89v1E/UbAdeOBu4YCkw9FTgJckKy8pfhHfTU28BBp8EnHAlYE8DALh7OvDxZ19g9sWXwGaTmNGKojmhkEy4CAQCgUAgEAgGWbRoEebNm4epU6di2rRpeOGFF1BVVYVbb70VgMezanV1NV577TUAHgHy+uuvx5NPPonTTz/dp3FMTU1FdnY2AOD222/HWWedhb/+9a+4/PLL8f777+Pzzz/Hhg0bYvOQIEIkwQJufX0LPt0tV7GPpY7i/aKXgCXXyhOv+qOxTO/cDay6G9jznvp5RzYwaARw5u+A8Zcpz9tSPeavgRChkEAgDGCIJpJAIBAiy5w5c9Dc3IwHHngAtbW1mDBhAj7++GOUlpYCAGpra1FVVeVL//zzz4PjONx222247bbbfMdvuOEGvPLKKwCA6dOn480338Q999yDe++9F2VlZVixYkXMYkQCRIgkhEFlUzfOeXSN4vgJVCU+cvwRaAuSwZhZwNgLgI9+CxQcD4y7GNj+BjB/FZA91GPmWrEWGH8FMPN+oOUwUDI5Ak9CIBAIBAKBQCBYw8KFC7Fw4ULVc17B0MuaNWsM5Xn11Vfj6quvDrNk1kGESEJI9Ll5VQESAM6gdwXP4O46j7YQAE5Z4D9+3r3+v1k78H+V/t9EgCQQCAQCgUAgEGIOESIJpuEFEePu/VR27PNFZ8PO0Fj87k78ZPwFwGfLPSfmvesJwzHiDCBneAxKSyAQCAQvxJyVQCAQCFZAhEiCKQRBRNkfP5Ydq3hotm9i8p8fFwNPXuA/WfajaBaPQCAQCAQCgUAgRBgiRBIM8fAn+/Dc2kOK44eX9guQ3z4PpA4CVi5QuZpAIBAI8QDRRBIIBALBCogQSQhKTVuvqgBZ8dBsUF8+CKx/TP1CsoeRQCAQYgLLsuA4LtbFIBAIBEKSQoRIgio9Lg6pNgZOTsD0h7+UnbtoQjGenXsicH+OdgbXvK4eeoNAIBAIEWfChAnYtWsXeJ6PdVEIBAKBkIQQIZIAAKhr78Oza8px3emlmPXEOs10lQ9fDPR1AA/m62dIBEgCgUCIGQzDYNKkSWhpaUFFRUWsi0MgEAiEJIMIkQOcPjcv87T66qYjquky0IMfUhYAS1ROXv40MPlnnr/bqoDsYdYXlEAgEAimsdlsst8Mw8SoJAQCgUBIJuhYFyASPPPMMxg5ciRSUlIwZcoUrF+/PtZFspwv9tZjxF0f4ebXNoecx/qDjYpQHWqcTB3wCJBq/KnFL0ACnjAexHEDgUAgxAU07R/mCwsLY1gSAoFAICQTSSdErlixAnfccQfuvvtubNu2DWeeeSYuuugiVFVVxbpoliGKIh55bSUqU64F9v0vpDyWfLAb8176zvd7KNWAnY4FOJE6hJOpA6hMuRaVKdeiCC1Y6ViizGDEmcCSdoAmq9oEAoEQr/T09Pj+zsnJiV1BCAQCgZBUJJ056+OPP4758+djwQKP5mzZsmVYtWoVnn32WTz00EMxLp05tu36AUVbHsKmkmE465ST8dKa/Vi56nPcyb6FVY5tAIAX7E+A4/+E6rZefF/ZitZuF34+YwRYRrk+IAgi7vtgN17/xm+yWohWfJdym+/3B457Zdd8m/IreSbTfgVc8BcLn5JAIBAIkYKE9CAQCARCJEgqIdLlcmHLli246667ZMdnzZqFjRs3ql7jdDrhdDp9vzs7OwEAHMfB7XZHrrBBqDm0C6d+cK5HV/zRucBHwHwA8x3KtKPv/hiAf6Lwl4/3GrrHTsd8ZFG9hsvk/sV6oPB4IIb1YhTvu4vlO0xkSP2FB6m/xCdZ3qHdbveF+nC73VF7nmSpv1hA6i48SP0lPvH2Dkm4JHUoURTFWBfCKmpqajBkyBB8/fXXmD59uu/40qVL8eqrr2L//v2Ka5YsWYL7779fcfzFF19Efn4QD6QRpKfhEOZWK8tlhIudS1EulsAFFqKKxXI2urAj5WZTeb4/+bWQykIgEAiE2CEIAg4fPgzAY84ay3GNQCAQEpGmpiYsWLAAR48exdChQ2NdnLghqTSRXgLNd0RR1DTpWbx4MRYtWuT7XV1djfHjx+O8887DkCFDIlrOYGx7eT8m17xp+rqPHH80lZ67/DmIE66G7S+eyQV35YsQx10KeturENPyIB5/OWabLkVscbvdWL16NWbOnKnwTkgIDqm/8CD1l/gkyzsURRHbtnm2PxQVFUVtXEuW+osFpO7Cg9Rf4hNv77C6ujrWRYhLkkqIzM/PB8MwqKurkx1vaGhAUVGR6jUOhwMOh99GtKOjAwDAsmzMG+6En/8D/3vndJw4PB3DP/sF+vInIKVgFDDndUAQgAdyw7/JLevBDj7R8/eSdgCSRnH6LeHnH2NsNlvM32MiQ+ovPEj9JT7J8A5Z1tOr5+XlRf1ZkqH+YgWpu/Ag9Zf4xMs79PahBDlJVSt2ux1TpkzB6tWrceWVV/qOr169GpdffnkMSxY6fOogDD5lNjDtJ0iRalPpMB3rznsPKDs3vDwIBAKBkDDQ4Y4bBAKBQCD0k1RCJAAsWrQI8+bNw9SpUzFt2jS88MILqKqqwq233hrrooWHmjnuBUuBVX8EfrsfyCz2HOtuBngXcOhLYM97QN4Y4MxFQHcT0FUPDJkC0CxgS4lq8QkEAoEQG0pKSuB0OpGenh7rohAIBAIhSUg6IXLOnDlobm7GAw88gNraWkyYMAEff/wxSktLY10065l2m+eflPQ8z/+Tr/P88x3PBwrHRa9sBAKBQIgLBg8eHOsiEAgEAiHJSDohEgAWLlyIhQsXxroYBAKBQCAQCAQCgZB0kA0SBAKBQCAQCAQCgUAwDBEiCQQCgUAgEAgEAoFgGCJEEggEAoFAIBAIBALBMESIJBAIBAKBQCAQCASCYYgQSSAQCAQCgUAgEAgEwxAhkkAgEAgEAoFAIBAIhknKEB/h4HK5AABbt25FbW1tTMvCcRwOHDiAwsJCsCx5VWYgdRcepP7Cg9Rf4kPeYXiQ+gsdUnfhQeov8Ym3d+iVB7wyAsFD7N9MnLFu3ToAwOWXXx7jkhAIBAKBQCAQCIR4YN26dRg1alSsixE3ECEygLPPPhsA8MUXX2Dw4MExLQvHcVi7di3OPvvsuFiJSSRI3YUHqb/wIPWX+JB3GB6k/kKH1F14kPpLfOLtHdbW1uK8887zyQgED7F/M3GGzWYDAIwdOxZDhw6NaVncbjcOHz6McePG+cpFMAapu/Ag9RcepP4SH/IOw4PUX+iQugsPUn+JT7y9w8zMTACIi7LEE8SxDoFAIBAIBAKBQCAQDEOESAKBQCAQCAQCgUAgGIYIkQQCgUAgEAgEAoFAMAzZE0kgEAgEAoFAIEQBQRAsDRUhCALcbrdl+cUDHMfB4XCgo6MjKo51UlNTYbfbI36fZIMIkQQCgUAgEAgEQoRxuVyoqKiAIAiW5OcVIGk6+QwLBw8ejOrq6qjcSxRFpKamYvTo0UlZl5GCCJEEAoFAIBAIBEIEEUURtbW1YBgGw4YNC1tY8eZnt9sxePDgpBJ+RFGEIAigaRoURUX8Xt3d3aivr0d5eTnGjh0b0fslE0SIJFjKocYuDB+UBhuTPJ0ZgUAgEAgEghYcx0EURd0QEBzHoaenByUlJUhLSwv7nm63G06nEyUlJcjIyAg7v3hCFEXwPA+GYSIuRAJAeno6AE88SJfLRUxbDUJm+gTL+HBHDc57bC1u+Nd3sS4KgUAgEAgEQlTYsWMHdu7cqWumyvM8AFgmoFid30AnPT0dFEWht7c31kVJGIgQSbCM1zZVAgA2HmqObUEIBAKBQCAQooAoir6/u7u7g6a3WrMWDU3dQIDUo3mIOSuBQCAQCAQCgRACUs+oR48eBc/zyM3NxdChQ2NYKgIh8hBNJIFAIBAIBAKBEAINDQ2+v3t7e+FyuVBfX+8zNyUQkhUiRBIIBAKBQCAQCCbheR719fWq55qamqJcmsTC6XRi8+bN6Onp0U23f/9+VFVV4ZxzzsEdd9wRncIRDEHMWQmWQYHYkxMIBAKBQBgY6MUxlJq5JjIVFRVobvb4uqAoCna7HTk5OSgpKQHDMCHleeONN+LVV18FALAsi2HDhuGSSy7BT37yE0ybNk2Wb1lZGSiKwsqVK3W93xKiDxEiCZYhQgyeiEAgEAgEAiEJaGxs1DzndDqjWJLIkpWVhZEjR0IURXR2duLIkSMQBAGlpaUh53nhhRfi5Zdfhtvtxvr167FgwQLU1NRg2rRpsnSiKIJlWQwaNCjcxyBYTEKZs65btw6XXnopSkpKQFEU3nvvPdl5URSxZMkSlJSUIDU1Feeccw52794dm8ISCAQCgUAgEJKSrq4u3fNtbW2650VRRI+LC/lfr4uDIIrgBf8/N8cb+sfzPARBMPwPABiGAcuyyM3NRU5ODlpaWsBxHCorK7F9+3Zs2bIF+/btk3mo5TgOhw8f9p3ftWuXz8zXZrPh2LFjyMvLw49//GPMmjULa9aswcKFC3HcccfhscceQ1lZGRwOB44cOeIzZ+U4DhUVFfj2229xww03YPDgwXA4HBgzZgxeeuklNDU1Ydu2bfj2229x5plnIi0tDfn5+bjuuuuIibHFJJQmsru7GyeddBJ+/vOf48c//rHi/COPPILHH38cr7zyCsaOHYs///nPmDlzJvbv34/MzMwYlHhgQcxZCQQCgUAgDASCCYnB6HXzGP+nVSFfPySTwZJzC8E1dIJinRAEAft+2Gno2lEFGWBoY3O26upqCIKAzs5O37G6ujq0t7ejpqYGHR0duPDCC5GSkoK6ujocOHAAEydOBMuyqKmpQV9fH8aMGQOWZeF0OlVjadrtdhQVFYHjOBQWFqKmpgZffPEF3n77bRw7dkyWtrKyEn19fXjkkUfw3Xff4Z577sGoUaPAsixaWloAeJwdzZ07F/Pnz8eTTz6JQ4cO4amnnsI111yDL7/80tBzE4KTUELkRRddhIsuukj1nCiKWLZsGe6++25cddVVAIBXX30VRUVFeOONN3DLLbeoXud0OmUmB96PhOO4mNuzu91uVHYCY+79DADwya+nY3RhBgDgi30NWHewCXdfNA776ztx1XPf4riiDFw8sRi/PHsU3tlajUON3fj9rDGgKErxO5DGTiemP7IWF51QhKd+ehLu/O9O/G9XHbbf8yOkO4w1E0H0dwwtnb3466r9uHhiMaaNyrOgNpTlffzzcsw9ZShOHJqtOO99d2beYW17H856dB0AYNVvZmBUQbo1hdWgvqMPy744hOtOHYYJQ7Iiei+zhFJ/wdh5rB0/fv5bLL5wLMYVZ+KGV7bgdzPH4JazRoaU3+YjrXh3Ww1+P2ssctKs3SfR6+Lxl0/24/zjC3DO2ALf8bqOPjzxeTmuO3WYarvzEon6i3c6+zj8ddV+1HU4sfZAE04oycR7v5wW/MIIIYoiJv/5SwxKt+P+y47HTa9uxTNzJ2Hm+EJD1xt5h6Io4q+rDuD44kwUZjlw/ctbMDIvDSeX5uD2H43GoHQ7ln6yD2ePLcCPjivQzAcA/vLxPryyqQrPXjsJv3xjOwCgKMuBDb8/W/Oa9QebcNNrWzEo3YYv7jwTGQb76kjzj68OIcNOoxDx+w3M/vvXONTYjf0PzNJM80N1B/7z3VHccV4ZirJSfMff31GLL/Y2INXO4MZppTh+sHyResexdlz9/Le4Ydpw9Ll5XDJxME4f5TfFc/MC/vLxfgzJTcGhxm788qxRKM1L858P0vYONnThpa8rcds5ozAsN0127u2t1ahs6sFvZ442Fffu5Y1HsPST/QCA5QtOwdTS3KDXbD7Sirkvfo+7Zx+HG6fpmzUeqO/EvzYewa/PLcOQnFTD5QIAXhAx7r7VOGtMHl66forv+EtfV+LhTw/gw9umYVxxJjr7OJz8F4+AMGcUhd2r9uP3FxyHqpYePLP2MBbMGIHa9j6s2lOPxRcepzm3OdjQhae/Ooy2Xjd+Pn04zh5bgAP1nbj4H5sAACt+cSpq23rwvzXf4KbppZrCWFZWluwdut1uiKLo0+61drtM1YOViKIIUQR4UYQoiGAZ2vNbEMDQNNSajjceZm9vL9rb25Geno7W1lYMHjwYWVlZoGkapaWl6OjoQFNTEwblF6DP6URqairS0jzt1G63q+b73Xff4e2338Ypp5wCmqbhcrnw6quvori4GOnp6b62zHEc2traQNM0Vq5cic8++wznnHMOdu3ahREjRiA3NxfNzc146623MGXKFDzyyCMAgKFDhyI7OxsXXHAB9u/fj7Fjx2o+n9r8n+O40Cs7iaFEaZTUBIKiKLz77ru44oorAACHDx9GWVkZtm7dismTJ/vSXX755cjJyfFt4A1kyZIluP/++xXHX3zxReTn50ek7Ga4fZO/k0tjRTx0Ci87ftUIHisr5Rub7z+Zw31bPedvP4HDqCx/+l+fwGG0irzy9900yjs81s1/mcrh7s2e9CMzRdwxwZib6qd+YHCo0/Ohnz1YwNpaT35PTrP+4/vnPho/tFqb/xO7GFR2+XvOSJRbyjN7aOxvj1wdxRvStiwl1Gf35ndagYBrRytXNsPhqxoK7x3xfFfS8r1+kMbmJhr5DhH3nkzct0tZWUFjbZ18h0Qs2/XhDuDJ3co2Z2WZdrdSeGGfumOJERkiJuUJqu1IjVC+D+k1Fw/jMWto7Ifzpj7gwW2ecsVrvyaIwJ3feMp48zgeJ+Sq15u3fsdmC7htvKA47iXwOdXepTTN+joKb1f4202eQ8SfTPQnf/iOgZOnUJwqYvEk+XXee98xgcNIEwZYwZ4p2DXB0v/2GwacSGFouojfn2iu73yngsa6OuVYGXj/R3cyONotl35+fyKHVw8waOijkMqIcPKAAAqXDudx/hD1937Xdwx6eU8+FEQsm8bL7iXyHFyNlQCAi4Zqt5+cnBzZPJJlWRQXF2PYsGGw2+040inCyQnIdwCp/dn3ckBTv15jmGQdu8MNtLvkx91uFzpamzG8dAQYu2eRQxQEUJSnjUux9XfNvOg5R1GAnQZc/c2aoQBRBAQAlCQ9AFRVVaGlpQU0TfcLnyKys7NRUFCA8vJyjB8/Hikp/kWWiooK0AyDwUOHo6uzA8eOVMLhcCAzMxPZ2dlIT0/HTTfdhDfeeAN2ux2CIMDtdmP27Nn49a9/jXXr1mHFihXYu3cvAKC8vBypqam4/vrrcfzxx+MXv/gFDhw4gHnz5qGzsxM2mw379+9HdnY2iouL0dLSgquuugrfffedTGgVBAG9vb348MMPceGFFyreV29vLw4fPoza2lrFftampiYsWLAAR48eJfE/JcTHsqUF1NXVAQCKiopkx4uKinDkyBHN6xYvXoxFixb5fldXV2P8+PE477zzMGTIkMgU1iButxvY9JXvdw9HYfbs2QCA2zd5tJN5Q8uAykrZddPPOhvY+jUA4LgTp2Lm+EJf+vEnTcX5xytX4u/b/hUAz8rLmef8CNjs0cgd7aYxe/YFhsr7es13QGcbAIDNLgJqPRvOvWW2kicObADQo5m/2+3G6tWrMXPmTMPevBZv+QKAf3CLRLmlLP1hLQBnVO5lllDqLxjeNhhIqM/uzU9Mz8Ps2aeEXC41Nr6/Gzji8bonLd/Sv3neWZOT0i13JOov3nnv31uBOvl+k1i26y/2NgC7tyuOGy2TkXfYt60a2Ke+777RzWLQkKFA//gT7L6hfB+ya7KHYPbsE3XvEQ321HYA277x/Y7Hb4AXRNz5zWoAwPDjJmL2VPVJobd+24VUzJ59tuK4l8B3pPYupWn2rT4IVFT4fjcH9CfB2p43/7peZT/kG+snnYJzg2i/9cps5DuRXmO0fdf1Gp9TeHnz5c0AWhT3Cby/Wr2fNPV0NOzcDAA+wRAA2EFDMXv2RN2yAoAISpG34PTv+csfMgJnnDwEw4YNw9GjR2X5FBQUYNiwYb7ffX19OHr0KDIyMpCSkgKqqwMpNgY52anISfW859YeN7raegEARfn+FX+urQ9O0SU73tfXh672VthYBmL/o9EMA5ryaBilOGyeRQsXJ/jO2WwMOLdnzsPQNDhB8DlKsdn8ixwMwyA7OxulpaWgKAo2mw0URaG3txc0TcNms8m8qVIU5dMcZmRmYeLEiWhvb0dHRwfKy8tRWFgImqZx9tln41e/+hXGjRuHsrIy9PX14cCBA6BpGunp6b57e/OTata9mk2GYXz3pmkaDMP4hN1LL70UDz/8MACgo6MDVVVVmDBhAgYPHqzqVZamaVAUhVNOOQVZWXJti54X3oFM0giRXgLNN0RR1DXpcDgccDgcvt8dHR0APCtG8TbwAVCUiWaUvpEYxv9aWZaRXcMwjOpzSauIYf3X86JouB5oyl8WSvJ3JOqRlpiP6OVvs9lCvn/E37+kzuOxrQHh1Z+Ze4SDd1CzEpr2DzBaeRu5ZzTqL16Qfv9eYvnstIbrebNl0nuH0r42EAoUKDr8ftDodRRt/XcQCiwrr5N4/AZoiZpGa0yUQQUfZ4IhTaM2bqvlYaTutM4Hjv1mCeU7iVTe0jmc2f44sD368uwXfowQmE7k/KaOFE2DZVkMHjwYtbW1snRdXV2ya3meB0VRoGkaNC1tA5Tvt/RZ5WmgOO4VeiiKCuobX20erDc3DjzHMIxM2wh45s8URaGrqwt5eZ5tS4IgoLu7GwWFfmWFzWZDfn4+8vPz0djY6BO209PTMWzYMJSWlsJut8PlCm7ey7IsRFHE6NGjIQgC1q1bh3POOQdOp9MjmPeXe9y4cfj6668xcuRIsCyL1tZWiKKIMWPGBH1mtfm/Vjsa6CSUd1Y9iouLAfg1kl4aGhoU2slkIpgzG6N7ImhJOkEywMarsTNt8LnMEO1njde6TTQi0BQ08yTvLHEYaK/KzP63gY50F08sam0gO6ELpZmG0+9Goqb5njblfVQeLF73A1sFwzAoKCjAsWPH0N7ejt7eXl/oj0GDPGa8jXV1aGtrQ19fH3p7e9HW1obUVPU9sV7T076+Pt/e0UBYlkVOTg5EUcS1116Ln//853jhhRdQX1+P7du347///S8AYM6cOWhpacHcuXPx3XffobKyEt988w1uuukm8DzZimIVSSNEjhw5EsXFxVi9erXvmMvlwtq1azF9+vQYliyyWDVvsHr+Een5jEGnYqYgcS4JXrTaF2khiQMR+AlGMNJMElHoS6b2H87YrLW4YtU7FQTRZ1o5efJkjB8/Pswcw3xxUW6qQ4cORW5uLioqKrBnzx44nU6MHTsWDOuxBKEoCseOHcOePXuwf/9+UBSFUaNGqeZlt9tRUlKCjo4O9Pb2KryyehkxYgTS09Pxq1/9CmeffTaWLFmCK664ArfccosvvEhBQQG+/vpr8DyPCy64ADNmzMBjjz2G7OxsTQ0vwTwJpZ/t6upCeXm573dFRQW2b9+OQYMGYfjw4bjjjjuwdOlSjBkzBmPGjMHSpUuRlpaGa6+9Noaljj7SLiiwP9FerZZoIkMdfaLYeSXioE5IHEj7SgZiO4v2ej8kxB/ktcSOZOxbvf4zaJrW1LIlMiNHantQp2kaw4cPx/Dhw2XH3bxHi5hfVIThw5T+RV555RXV/EpKSvDcc89BFEWfxvC4444DAKxZs0ZWppEjR+L0009Xzcfr0GjlypWaZSeET0KJ45s3b8bkyZN93lcXLVqEyZMn409/+hMA4A9/+APuuOMOLFy4EFOnTkV1dTU+++yzAR0jMtqmI9EiEprORHhugpJITEqIOat54s2aMtbvijSV2L+DeCUa30q8fY+xIhr14HUCQyBIeeaZZzBy5EikpKRgypQpWL9+vWbaDRs2YMaMGcjLy0NqairGjRuHJ554QpbmlVdekTkZ8v7r6+uL9KNoklCayHPOOQd6EUkoisKSJUuwZMmS6BUqCQlZExlFIrH/J9pPHf+1PHDRbl3krRGME00T+XiUGeL1azE7xBGBzEKiXJeRuB3FsBD5/lAjFK3q6dNLVVWVQktHSH5WrFiBO+64A8888wxmzJiB559/HhdddBH27Nmj2h685rknnngi0tPTsWHDBtxyyy1IT0/HzTff7EuXlZWF/fv3y64NdHgUTRJKE0nw4DUTANQ7SOkAGTj4GQkLGq8Dv5RI7IkcqDR1OdHeI3cA4OYF9MU4xFtbj8tQe5W2cSfHo9sZfsG1FikSYH0lqehz86jud3dvlnBfVWtP5AKB84KI8oZOdFnQVo3Q6+LR5zbnTEIURbQZrANBUE/LWRu+NW7xPjsviGjvtcaZSh8HNHbKY9VxvICOPmP5J1NfFZZjHQvmCtI5FwAwadm+v7PylGFUxo0b5/u7sbEx/AIQ4obOzk50dHT4/gXGk/Ty+OOPY/78+ViwYAGOP/54LFu2DMOGDcOzzz6rmn7y5MmYO3cuTjjhBIwYMQI/+9nPcMEFFyi0lxRFobi4WPYvlhAhMgEZc/cnhtMaN/Xz99J8QJRaoxOd7ypajBYrbCLhnTUhpGeLaejsw9Q/f46THvhMNjmZtWwD/u97NqITaT02V7Zg0gOr8as3tgVNK20KUx/8HCfctwq9rsh7X7Nqspgs9ESgzsfd+ylmPPwlth9tM33t4caukO/7+OoDOPWhNfimQb+fcXLaz6xXH2c98hXOf3wdJty3KuQyGsXFCTj+T5/ihPtWKfp2PRb9dwcmPbAaX5c3BU178+tbMOmB1dhxtE024b9ni7aGJpYcafbH+WM0ViS/2Fvv+7u2Xd9cbNIDq7GxvAlXPbsRJ92vHu9TSrDRq8fF4f++ZzH9kbXYW9vhO37xUxtw4hLt/J/+qlzzXLzgCmFlwewCiBQ3r97m39mq7rRFjXMfXRNwxP8GeUcWgsFxxheL+BgtvJB1eWOMHz8e2dnZvn8PPfSQIo3L5cKWLVswa9Ys2fFZs2Zh48aNhu6zbds2bNy4EWeffbbseFdXF0pLSzF06FBccskl2LYt+BwpkhAhMsFRk6Vkx6jAc8G7isAU0kHMcLlMX2Ey/yTo8eJhpfiz3f6J0vaqNt/fx9o8k6bvK1ujXSQAwAvrDgMAPtpVGySlfKGks3/Bo7whdAEC0NkTKfk7FMEmmdlf1xmxvO997wfT17y7LfTg0E99cRAA8N/D+kOkTSXenxStb9yMdtWINh7QbrMNnZ5vmRdE9JqYjHvrz4hg8nm/wPXqxkrZcScfnx31W1v8AsS4YnWfCY9+dsD39+Ds4OZiz6w5hB0W9QkH6v3914rv/QHs99frf2N/W+U3c0uGMdLLPoN9y7RReYpj9R3h7xc71hr4vXq+STolA1kpwWNNeuOP+67W+aZDEZiN9hEEfYyE/tizZw/a29t9/xYvXqxI09TUBJ7nFeEFi4qKFGEIAxk6dCgcDgemTp2K2267DQsWLPCdGzduHF555RV88MEHWL58OVJSUjBjxgwcPHjQ4BNaT0LtiSQYw+r+JB77p0iUaSCG+EimiYaVaGnwyWCtTST3Ug/kdiqKA/v5I4E0FnIyegtNNhwsDacBDWaaPbqab61FeW/Ij8B0NpsNFEWhsbERBQUFEDmPpY/LSaOP8Twf53JC5DxWLlKHKWrHeZ6HKIpobGxERnaOx9EKPG1aCJzPcJ66cXOC/xzH+KwpOIoCL+3DufDqkhNE8N44jyHk5Y0TSdN0xGPgiqIIp9OJhoYGiKKo6ygpMzMTWVnBtc+Asn2Iohj0WdavX4+uri588803uOuuuzB69GjMnTsXAHD66afLvNHOmDEDJ598Mv7+97/jqaeeMlQmqyFCZJITyqcXOBUcKBPnAfKYMqQTKLXHH6gTLCNxIgdmzWhjxlQyGkSlNPH1yASDiLK/yUtMdLiORtTU1ETvhkGaDEVRmDBhAn74wWNBcfjwYZx88slgGAZDhw7FsWPHUFlZiYZ+DSfXbkOr3TMdb+l2+Uzh7b3+cCFaxwVBQEtLC5paPFZD3nEpsIhs/6DGC/4Wz9IUuP5+m6YAaRfOhul4QhBFX36h5mVE6LIKURTBsixGjx4Nlg1PNMrPzwfDMAqtY0NDg0I7GYg3nMrEiRNRX1+PJUuW+ITIQGiaximnnEI0kYTQUZ/kS1ZZLfgAQxliI/3dk5V5awhWj4lQz5Eoo5E8E6FuokkkZciQFsMsKE88vGIi4lhPJBYMrewPLBm3k6jh6NWHyLnB97SjtrYWTZV7IfJZoBiboWuNInIu8D1tYNJzZXkDlOaLt9nkZq61tbUoKSlBRkYGxowZA7fbjQUr1wAA/nDhOFxwnMdByoqP92L13gYAwBe/Pcd3/YpP9mL1HuVxwKORvO6FjaAooCDDgZKcVOw41iZL88rPTwUAPL56P3Yea/cdu/Hl7wAAl51Ygg921ijSh8onu2qxYvPRkPPiOA7ff/89TjnllLCFOiPY7XY4HA7QdPi7/Ox2O6ZMmYLVq1fjyiuv9B1fvXo1Lr/8csP5eDWkeue3b9+OiRMnhlXecCBC5ABDqzuVDjjJNPjEN/FV0cmkcQ5Xu0C8s5on7jSRSfKyPM9hfi87QRtp/2DE2sLypmRCsCGLVerwPA++uzVAqANcjUfgKB7t+21F9bmaqjz37OmAo3g0RCH43rlAYcQrRAIAwzBgGAbVnZ583GB9YRo63JTvuDR0g9ZxL9vrPaaxwwexcDMittXJneJlZ3s8yh7phO9cdna27+8zx7Oya7zpQ6VTaJbdxyxutxtOpxNZWVkKgTwRWLRoEebNm4epU6di2rRpeOGFF1BVVYVbb70VALB48WJUV1fjtddeAwA8/fTTGD58uM+z74YNG/Doo4/i17/+tS/P+++/H6effjrGjBmDjo4OPPXUU9i+fTuefvrp6D9gP0SITHCCapIsuEc8zsUiMa7G4WNGHDI/UUd7sYXspdIiokJkCDPpeJBprRBkw80h3CKYup6Kz/FCj3g3Zw21n0l24bOqqgpcZ3PQdOHWg+BW0wR52owoRsCVaqzem8UNJtnbXzDmzJmD5uZmPPDAA6itrcWECRPw8ccfo7S0FIBnUaGqqsqXXhAELF68GBUVFWBZFmVlZXj44Ydxyy23+NK0tbXh5ptvRl1dHbKzszF58mSsW7cOp54antY4HIgQmYToxokMJb84H2QJoSNtH+p7IgcoRvZEDtjKUYePM+khWfotK6uVNFkPZuvU6m89WHbkPQUn0ONpxODloZwEd1/cd/6hmPDG9xMlJgsXLsTChQtVz73yyiuy37/+9a9lWkc1nnjiCTzxxBNWFc8SSIgPQnCSYy4WlGibv8XDnJto09TRrBfpAk10ipIwRFITGas9kUHvMVA6R4Mka39ipC1Z6QDEisWqeBhfrIKiYMiE1Ivg7LH25hLczccg9HoEWIo2p4cx5AAlzPcWqnVanMvFhDiFCJFxjJG4a8FXNKmA3+q0SILK76uTr/A9smo/yhv0y1LVbGGnbZKv9jVgxF0f+WIDfra7Dhc8uQFbmsz1ikb67j01HXh01X50OzmIoohn1xzC4pW78K8NFSGUXJuPdtbitU2VluapiqSKAmO8BZ6PVzr6lIGcw53Mag2o3jiUXnpcHB5dtR8/VLeHdb9kRhRFPP1VOdYfbFQ99/zaQ/hqX0ME7mt5ljHBqKCqJcREKvRKa7cLj3y6TxGTdeOhpqDXvrX5KN7eIg/2/sGOGvzn2yOWllGN2vZevKLS11U19+Cvn+7zxdWU1madJNbgBzvUvYC2dGs7wAgHV5DQFlc98zV+8drmoIuge2s78LdV+9DlNB74HoBvnFuz3/w3+pvl23DeY2tkIVW8rD/YiKe/Kje0eMv3dcPVUAGuvd5XJo7Tfg6+1z+HMTMWfF3ehH98KRf0RLdLkU70hq6gjA+Rr26sxMWPfYZujfr31oMyJqU+giDKynykuSekBfGXTM5hRNFz3w0H1b/3rVWxiTFNiC7EnDWOWfTWrqBp+lQGGOlcwujqEktTcPOejuf2N7fLzm0/2oaZT6xDxUMXa17/4+c2yssQaelD8mA/f+V7AMD5j69F5cMX4+bXtwAADjcxuNfi285+aj0AoMvJ4dxxhfjrp/t8504bNQgnlIS3Gd3LbW9sBQBML8vH6MIMS/JUo0sigK3Z34gjzd0ozdOOkRSPeAN8e+NdAUBzmBM6tUmPAgpY9vlBvLDuMP7xVTkqH9b+PgYCWSmsqkC/ek+9Lwh6YB1tOtyMhz7Zp3ouXKaU5qK6zdyELJB4WEMJVwZ8b1tkQh/c/d4ufLyrDi+sOyw77n2fWnT0ufH7t3cCAC6aUIx0h2ca8pvl2wAA5x5XiJKcVM3rw+XnL3+vevwnz29EfYcTWypb8d9bp2le7y1nID9UGzevNKMtWrH5KB68YoJm2q1VbQCAT3+QhxMI7MIuetIzdnX0crr5BbLuYJNvnDPzjTZ1OX0C9/s7qhXn573k8Qo6ujADF5xQrJtXhrMJTQD43k4IgoBt29TfwfC8dHxX2Qrw/n7IwRrXlVz34reKY3yvzgKhoC/gjxs3Dvv2eerurf5Fk9vf3IYXbzhFlq6zrRXbtzeirKwM31W2+I5vrWrFycNzPT80+oGPf6jFo58dkB37ar9ywS4YnSp9tx6f/FDnu69au/h4V53iGCH5IJrIOOZAwAqvGqk2ZRBXWjJCGZ0EeQdyLYJNZBo7I7MKG03MTNb21HSgJmCC2tSlXLHUw4iA39ZjLk+zuHn5INje69ZIGV1CMa2RmlP2uoybPqmRovJdBUKBwu4aooH0cs3UYarH9QS5uvY+zXNSQgkzdurIQeYvCiBspzZhlyB8jjR3h3W91re4rV944STfnZHvVvptcryyhsxOZs2yT8PCp77DM4ZJJ/HxQDBNpJdADRbLqL8Ms31W4DhnFKnGrbJJ21Kp2oDmLTfN7vu7sVFbQBqS4/FaKrj9/YrNhBCphsgb03iqkZ6e7nOk4mXjIaUzoIbaoxAEQWHu2tARfF51tMXc+7HK7PpoS+yszwjxAxEik5B4mLhEmlhrCKzYCxUP5naB4wkdcMCqAUfPvEbtXCh1Y2V9Gs0qHt5hvKBVFXotyGjzilbA6Xgk7DYWgmWKpfcPQGpeS8XBDETr+QZwk7OESPWNx44d0z4Zh/1xbm6u7DfX045Dhw5BCKLFBIy1QbNzEat8P5DvgwAQITLhUesOZH2EwQ+dTIbNoVZfkXDMQ15LaERjgCODqJxI9iEhOdaxvBTmiWa/mijNUWpmGbhoRfAQSrUEu4bv7YCzrhycy5j2PxGRfm7u1tqo3DNYvTMMg+HDh/t+u9sb0NbWhro6j7lnoMMgMw6EgNjN3ZLViRbBHESITHCCCS4Kxzrku7eEeJigWkFg+1BoIi26TzRc6lv5TozcnnxKcrQcuFihRYxVvxXstlZM4IL14eFaPURKUFPL1cidpPuNGZWyRftdD5QxkWv3OMbpqjfnvCjUNm5lOCRGEmze6GKt4PSYcUfy9dIOY/4DMjL8fg285amtrQXf3aqsYFks4vhloHw3BH2IEJngqPeneqaDWseTRSyKDmoTZrM1GA81rjBnjUGPEJmmF94IFw/vJlmI2WQjSfq0cB8j3uZ6MnNWlcJFu7yxaCbR0OLE23uPBkp5LLyXG+x6JsPYvuvUVL+jKGmOXGczXI2VATc1tgc2VAby1gCC9RAhMsFRW6WWmgvFbAU/es5ZdSHCsTkiNbmJxluI9rumKCpZ5BRLiFQoCSBxTacs2Tsd5vXRHAOM3CtRzFnjuGiGGGjCQkpKCmwOh+yY0N0W0XtSTAgBDoJ80K6mKvA9xGEbITEgIT4SHLVIBNK53MAaRqKH2nw5Geo60Atmos5DorUnkgSb96NpzmpF5gnaDqOKRh2FK6hZ3cbVNJFksY+gB+f2ew0XRfX+PT8/H1m5cm/mfF9nmGOB1AkUo9yvGIpnKAPl4ToaIbrlnlnj7QsZaIsUBHWIJjLBUTerlA7SlCyMQzjfPW8kdl6UcLqNmXxEam6i6tAoyDVuXtCdLPW5ecOTqcDQHFI4nftwvCDbkxTYfgIHBuv2ROqYWAe5Vu9ZzeQTTt5qWFE3giCizx1eOJJYIq0/zVes0+mohXhQzaL/Xt5/RtDKmRfEsN67GYx8zqKo3w7NCliiKGr2+VZqdEOdREqfh/Idk+arfl2o78zIN6YWFzaw2s20vWCYrToj9zX6PkRRNDWW8wa8iGrdJ1Tk/Yp6Ptm5clPS/Px8ZGTLj4mcS9HmRRVzUSNlteUNVRyjKCrkb4oL8k753g7NPizWiy56cwwziKLy24xW30ywBiJEJhiLV+6U/VaLISXt89/fXo0xd38SNF/OwKBywbJ1xoKwI7KaoEv/vgF7ao0Hdo4E3gD3Rulycjjjr1/itje2+o5JO+G9tR0Yd++nGLn4Y9lxtUn2n97/AeP/9CmqmpVxmpwcjxl//RJXP7dJcc7NCzjrka9w5TNf9+ctYOnHysDg0k7cxVkzWIWTy8kPrkZHn/XxK/fWduC4ez7B31bpB0fXI9xxdNQfP8a4ez9FQ2fieUxc+vFejLv3U5Q3eOLu/efbKtV0Wl2BixN8QeeDsf1oG8bc/Ynvn5HYh1rvpuyPH2PM3Z/g+ziJB3j+E2sx+YHVmufXH2wylI93Mrvg1c2Y8uBqdPZ/MzuP+U3jvtzXEEZJ5ajF/zQyoW7t8X/Lzd1qcXCVeXxzuBlj7v4EL64/bKqMgP8ba+5Sj7lX296LUX/8WHF8d418jPG2vWgQWI9j7v4EX+yttyTvfXVdOOfRr4IKMYAn1uO97+8O+54H6tVjc6rx4Y4ajLn7E7y/vRpOpxPbtm1DR0D84tq2Xlz44l6w2YW+YxRF4X87a+EoHi1LK11Ud7dUw1V/GO62Ov95UcSePXvw6IovFWURuiVmpTQLirUr0phGBN7bdgxXPLMx5CxGLva312gLlC7OM4/480d7DV9T2aTeX49c7Pk2t/fPpz79oRZj7v4E72zRCeNCiCuIEJlgLP/uqOx34EAHAJxEitSa2AXSYyA4e3lDV1wEo99VHaf7BXT68i/21qO+w4mPd9Wpnp//yveqxytVJsuvbToCNy/iuXWHFOd2HWtHfYcTW460Ks7tr+tETXsfdvRPKlt6lBM4O0PjUGOX77eNjcxqQFaKcUv6zj4On+8xN4EyMq4+/Mk+CCLw9FfKeow2T39ZHusimOaFdYfBCyKeWH1QN52W1sPMxNIZsFj23NrgwkSwhazFK3cFv3EULLYON3ajy6kd0Pw3y7eZyu+LfQ3o6OPweb/QIR0jpItYRjGjaTGyePi/HTW+v1d87xnPgn2uv3trBwCYmrgG8tQX6u30+XXmBdNwCaVZ/fLf+u8uME+9exxt6UWVgWDxa/Y3Bi+YAbTGPTV+3d/eb39zO44cOQJRFJGVKvHOCuDtLcf6F779TymKIjYdblbkJ22/gsuz8CH0dfk0kn19fejr68Njn+xSmKtyXfL82Owi39/2olGGnymQFzdUhnxtrPHOI8zw3Fr9MfaKpz0L27f2t/Hf9n/vhPiH7IlMdILsiRzoxEtVRNLpSKioWSlFSoMc+PjZaTZ09HH95+STAStItDiRcWQpbppgbZtlYrN3JtgnF40VfCvukMBNQ5VgzxOpb1fL3DMOu+aI91/RcNxiRbV2dnoWmrSqg3ak+f5mGMb/d1oO+J42AMD+PTvhrCsHk5olu9ZV71k8OHzYv4jgaqjw5JuSAVtOsSw9RVGgbA6FppNAGMgQTWSCY1Y4IXuh4wft/Q7RuT+v6QhFurprzb3Cdc5hdG+Zl2g1c6teVSJ/l6EukETaM2fw+IsW3MOCPAYa0tfideQV9F1FsKKT5R2a+Zy4Dms0jFagV26pYKh6Lc3AXjhSoRVk0rJ9f4v9q6V8r9Jqq6urC319Sq2a0NcF3mLPrmxWgef/tCzYBin3V+bm5lp6v0Qikce/gQ4RIhMcs/EK43HVNZLEegN6JAn30dT2t0arM490yAYjTibCbxnWPUMiN9NQtaiBMUkDv1W9b9eKdprIdR5NIumdVQ0rewZD/X8MGsJAmDRbUa3Z2dmqx2ULhjQDKsBLqtR5jl45Dhw4oHlOcBsz2TT6Lpm0bNjzS8FmF4K2p8BeUCo7P2qU0jzW7VbbMyzHbD2H2/Qi4ZF8AHwOSQsRIhMcNeeGySw4DQSi9fa09qpJB0WryqIIAi3J2bLnjXKzp6jo3zMeCbW7CdREWu39OVhuidJPGi1nooSbCcWzdagYaVKxqLVQml6w96vYExlkZh4v7V+vGEK/FlE2JokibClpGld4oGi/BlN/UV37rNDXpXkuVCjW5lvgpBj/Pk/W5vl7/PjxsgXQumN+nxZaZY2Ptxge8RwvlqAPESITHFXX5DEoRyDxEhw8HurCCLGIuaRtzuonXiYa8YhHhgy9fmShDuLjcwmJUNtIYEzSwPaol62R6gq6J9JAHvFAopQTMNaOg70XK/tCtZiUZssTbURRRG31MQjOHoiiCMHVC1EUZOUUBd7nJCZUqo9WqZpySgn2KvjuVoh85Jzt0YHmCv1wTn2nQBTjd/eRCGNYWnomACA1NRX2ojLf8b6ebhw4cADd3cG9UUeLSMztEnn8G+gQITLBUZvEJkCfmZSYFShkkwLJD7U4alp3DAcjsdEiRSQGokTRxKiRyN9sqHsiA4WFEMPRhYyRcodt+mXBe03ktqGG2qQ+Us8Yjw7NAP1Jc3l5OVpbmuBurQHf2Qx3SzW41lpZGnfzUbhbqsGb0JZJtXMA0NbWit27Qw/fUV5eDq6zGa7GIyHnAejXhU8TGXA82q9V6sAnErA27dAhnZ2d2Lcv9DBUVhPKOBvNhSNCdCFCZIKjPvGK3F6i+ByStYnTOURcoKmJlKkirbmXrjlrBN6RMU1VeDcOd+BLlrYZqhVqYO0pNJF618bJnsi4eocGyhL5uZryBoHfmfo+fqMLZ+YwtCUyQqOaWlB7I3R0+B3AeD2MCq5eWSlF3uPZWujVDpOjWKizuLG2twfz8Br+/dra2gCE1m69MSRz8vKDpnU4HLrnLYkPqZd/GB9mXPVBIUJEyMSFCJEJjuqAbKBTcXECXttUicONodn9t3S78K8NFWhRDRYt518bKtCmEpNQjV3H2vH6N0dUtWRW09nnxr82VKC23ZhZUDChIzDW5v66Trz+zRHFXq//7azBxnJ5AHFpHDxp6mfWHPIFDTeL3h6zt7ccUz3/8teVst9WvYY9tdoTjkMG2qC0GOsPNuLTH2qVaQLKWt7Qidc3VWoG1e5za8dGDazzHheHl7+ukB2j4HnHamyrasN3jcb1yEbmEIcbu/Dqxkq4OPXnae/xtOfGTvWg6pGiWyfGYSBbjrT6Akm7At7Lh5L4gQDgNhAMXYooinjzuypfjNSv9jfopm/ukvdJ3nd8rFXfVO6dLcfw+qZKjLjrI7y2qVI3bU2bvG/5obodbxiM3Svl3vd+wNNfleOH6nY4OR43/Os7vLheGd/Q6Lv4eFctvg7ogwBgzf4GfLZbHtMv3EnquoNNePiTffjT+z9gxF0f4b+b/YHEn11zCL97awce/sSvaaEo4JNdtVh/MHwPotLxUeu7iYQG3FlXDlf9YZnJ6bLPD+Dm1zYD8MTyNItafy04/WaOBxvk/aj0+xEEQVWo7XPzePnrCvz3+6OKc9EiWPv6fE8dDtT7n62qpQeFI8Yq0gX250xqFhzFo/F/n/r7FVtOMdiMPFm6UaNGYcKECaBTMjTLIPRpm5Oqdd1tPS78+NmN+CCgT1MrJ2DQEZxKQ9X6jmPN2gPmvl2yJzJxIXEiE5y8DOUKmZEx/5/rD+Nvq/YDACofvtj0fW/99xZ8V9GCT3+ow39vnaab9oH/7cFX+xvw+vzTguZ7/b++RWuPG4WZDlxwQnHQ9MHQE6Tue383Vm6rxksbKvD1XT8Kmtd3FS265/+2aj8uObHE9/uCZesAAAxFIdXuX6/51RvbAADZkgDKzRJh/HvJfapaenD3uz/gqbmTDZVHKkC8uP4wbjnbv7+iVzJ4/e6tHfjDhccprv/X1xW49rRhGk8YOj9+dpPst3SV/KIn1wdtg1JBcN5L36mmkQ5EOWk2nP+4p/45QcTPZ4xUpO/VESIDhemlH+/Fv79RTv69sS4Dueaf3wFgcFlVG04rK1BNIzdh1iyKjx89thYA0OXkcNu5ylhld/53O77c14C3thzDJ7efGTxDi+gyIUT++NmNAIAR+en4v3d2ys4tXrkLM8ryMTzPYzq2cmu1qXJsOtyMu1bugp2lsWvJLKw/qD+5Cnz/f/1kH17ddASPf6btsXHLkRZZIOx9GosIXgInUze+/D2auswL+a9/4zEZ/Nuq/bjl7FFYe6BRkff2Y214fp1fsFRrUxSA6rZeLPyPJ6i39Ltz8wJufPl7AMDWe2f6jmu1caMseH2b5rluF4+3txyTHatr78MvA8oXqtXAlxJhbdXuevzlyomKNOOKM7GnVhn+wQrcLdW+uILLPj8IwLMIsa2qzfJ7/SdgceK5tYdw7jiPNs4bb1EKBeDVjZVYVVenMHX1woWxishq7GcMRM/keMexNiz7olx27DdvbscNl56rSPv0V+WKY14CYzsyGZ5wGlOmTPEdk8aFdNbJ89Lb9+lWqaMrn9mIiqZubDnSistOKpGdkyZn0nIgOLuRmTNIloa2pUBw9yHV7p+iN1Tug7Ouyfcsx1p7fN9xPCGKIm74l/oYrcW4wZkRKg0h0hBNZIJTlJkS0nWbK/UFomB4BZjvDOYTbELnpbXH01nvrjYfDFltMUvPVGlN/ySsuk2piRyZn644dqBef8J4pFldg7HL5LMcbpKveq7R0KhUNClXR6UD2pdBVruPtmhpYCO/Khjc06C8DDbGQFcluWRQun9xZfvRNtXkUiE+GGrt18jiaWWz9Q4RtL5d7/veG6EJsRZm6tHLkeZulDcoNdANnX5HH9IV9iE5qUHz9Obn4gS41dxWB2FD//06dYTiiiZ9LWUwQhEgA1l3QL0vrWru8Wl5dcugoamWLrhJNfFpdv1YfVKsUCg0G7BuMYrUUsDFqS8anTk2uLljqKhptzZESXPk1cgDQGtrq+I8BWDH0TbdmJF8GGpah83fZ6fYtPtvvf6jodvrnZWCPX84AI+GUU3u/DbIIm846GkpHazy2dTGZi92SXo2Kx/2glKFAyEmwyNUZqYo9Txe7XO0LU6MEsq6w3n9ix2ExIMIkUlIXNjIx8A6IdOh7HDN1IWN8Rc6xWZ84hQr1Dpr6aBvRYiDWDmm0BIyjWokpOZBWpeYeTR1rU6YeyJlf8fDRxsZzNSzTAjRqV61uh8oBlFazxmpFmQ3soBjIWrPF+qzxXoslHoJjfq9Kenf2l+H0NcFd2sNBLdSKDFaf5FylpSa7hHe6LRsUKwd9qJRvr2OyhuGfz8taFZ7z2QkvL/SjjTYi0ahsEhpjeXud7IU6l0jbTkaSn0QxzqJCxEik5BITvwHyqdu5cCg7Vre+vfESTUwwUIcJJDcYmiMieDzqAl5YTupEtX/TjSsLXrsehgjzxEP4QK02p0hb7MJMFmzsohG4tFG9JVqmBRHm5QUfYslwdkDd7NyX6Re3TCMdKFVvxJDrWOXq1+wFb0ayehMWe0FI6JyHz0oikaBihAZLpHuwtSyD2p5FP/dEkEDIkQmOKofbOznOYQYIZ1IBptUGpl0xqopaWn5jLZtq8ekSH9TUfAjFTksLLtMe2Iw3UAjnGcP5VIz94u31yL7bi2wSDCNWuXpVJJ3kUKvzgMXMvjeDvA97RBc2jEf6+vrfX+zmXma6YQg8RfNYLRa9dL19O/l5HuCm+hbac0RqEEWXNr1EquFGVEUwfd2RDROp/p9wztPSC6IEJngqJqRRHDqbzTneJlMDLT+TOoIIfDZA5uKtuAidfiSODWYaCah8vIaL3tiPWXomJ6cRWEyFw+aPD0z6mDOmkIpfvS7AOvq2JB22Ux+ogDB2WO8X1SpcL3319SkvV/S711Vfm+uvQFcRyPcLdr7Yd1uv6BBp+WAzS5SLZ67tQaioO1wTF4eSTl4Y9ckKpaaJZv8ntLTlf4ZAOBo5WFw7Q1wNR4B19kcN2N1KONwJOJGE6JDUgmRS5YsAUVRsn/FxdabA8QTZjWR5GONPuHWuJmJq5432kASSejyVoGVJQ57TyQxZ7UcrSoNrOuI9GIG3kE8TNQiJcdKHy3UccKKsllqzmrAul89TJZ6aq6tDu7WGvBdzRaUTklVlXb4F9EbLkSnDYoCH1QIpCgKTGomjjv+BPWsRAEiz4HjOLjc2k6OBMn+e8Gt1IJa8a2wds9eRCY9J2jaSH6aXqHbCsyMu6IIHHec3Is6xdohcm50d/mdRvHdreCagzvVAsL/voJdH8p7iIO1OUKIJJUQCQAnnHACamtrff927doV6yJFnTiY58QN4QoKkURzj04YeUr3RAY1VzU0aQ6jMHFCIjyCKeczkStGSFhqRiaZTcTbc8YLmo51DLwGo8Kh9J3GwwQv1H7IUNs0kbfX3JPvblPPKqCgZoRxqbZQ7TqvQxW9wJauhgq4GioM3c/hUHcWI3JuuBorsWPHDlSV74PIBfeWG8ykUq+K9WrI7fQIp6KOqW6k8O6LZNJyon5vKRRFYcqUKcjMH+w75mo6okgncPHprZWQ3CRdnEiWZZNe+xiMWHnUJMQeqSYymFYynvdEaqG3uh3JZq92XyMTxFAm7cHTJi9Gp9xq2vmwZR0DGcSDOaueVBeO+WY8PJrVyLX96k+urokM5V4C3A0VsvtwXc2+mIRetOq5q8sf8kavPzAiLIicC2C0PYp6SS8eAbTulR1zt9bIfzcfg71olOJa2YKPykMZ2Y8a5JTvnJqmM9JQDKuIL2lJvqAQSi8u8J7QQ16hPlbTvEjsiUzCrmfAkHRC5MGDB1FSUgKHw4HTTjsNS5cuxahRyg7Qi9PphNPp75S9QXk5jpOtDMYrPK9clbxeJ9Drb9/ajpZu+XOZec7zHluDqybLg+f+6NE1inSiigDjvQ8viJj74ncoyU7Fsjknqt6HFwTT9d/Rp3xnFzy5AatuP0MWb+mJz8vx0a46tPb4V1jdbrdscN9f36nI6973d8t+t3UrB3O1Mv/n2ypFIGgA6NQI4r2/Vh5Xsr3XjcMN7fjR4xuC3u8vH/snBG7OX4eHGrtxzfObZGk5lbYDAD2SGHF3/Hcn3t9Rg7GFmVi1px7v3HIasvrjev3+7V041NQNQRSxu6YTZ4/Jx8GGLgiiCJamsOCMEXh2XQWWXaN8x4EDzeg/fgxOEHH6yFzUtjvhDihbbVsP3G63ZpndbjfcnL/cXb3+d9PrdKu+l02H/SZpem3N7XarDvl9LpciXSA8z2vm7XL5zc7+u/kY2ntc+MfcSZrl8LJmfyNO/cvnaOh04p7Zx+GGaaWqZTbKXz7eh/XlzVh562lIs8uHhHe2VmPZF+X457yTMa7YHxBaOlGu7+jDl3trVfN2Ol2q3wmnEbPv8qe/BgB8tehMyR4w4FirPKbpgboOxTNykn1ZRp/f7XZj/cEmLH53N+pV4q65BAq/fWsHHvvJSXC6efzurR2G8tW6lxXs0Ih7CgC17f7J9tNfHcRvA8orQsSzXx30/Z7+0Bc4fnAmfqjpwN0X+c3m3Jy/b9p4qBkj7vrI93tGWR5eudEfpF1Kj06MTaMIKu+xrsP/XFc8vQFvLjgVDE1BFEXc9NpWMBSFf86bDFEErvvX9xiUbsfTcyeBl+TV7VL/Fu957wfFsXvfM2/BJLp6DZlwvrX5KFz1hwAAtkFDQds9nlNfXFeO/3y+GbPGF+HEEvW4hM66clB0cAMyrqMR1KAhuOCJtdhf34VCsQ2AXNg7629fITOFBZOWA76nTZHHfe//gBllgyD2m7e6Givx7bffQrSn4acrquCsK/ffr7MZfU4XGNqT/30f7sH7O/x9giug35a+B57n8eK6cvz54/2KMmjFOl6xWc2TrHnpRTonCZW/rdqPX8wYjr+uOoCv9jfhnVtPk52f9tAXeOn6k/3lVBlNuvtcqm1TOg/dcVD+zLzKPlRRFDQ92I646yP8ZMoQfL7XX6cn3b9K87m8913+/VE8u7YCJw/PwUe76lTTrtxShUdWHcAz105CWYFyDycvCHjooz2yOYT0ff1Q3aZ4fu/veJmHc1z4fVsyQonxsMnDIj755BP09PRg7NixqK+vx5///Gfs27cPu3fvRl6eukeyJUuW4P7771ccf/HFF5GfH7kgxEa4fVNwGf/kPAFbm8OzSn5yGmfoXmYYnyNgT5u8XE9O83yER7qAx3exsmNevOW4YIiA2cPVBQa9sqo9y2XDeZw3xN/M1a5/9DQOf/iOgSB6BsHiVBGLJ8k76cDrTskX8H2T+jMGK6dZBjlEtDiV63Va9QcAV5TyOLfE89x/382gvEN+vVbbmVvGY/kh9TiZFw/jMWuoqLiXHnZahEuQ3zvPIaJZ5Xm0cDAiHjmVBy8Ci75R3vfJaRy63MDdmz3nZg0R8Fk1LTsfiLT8gecf2s6grpfynbtvC4M2l7y8fziRwyM71fPw5n3daB6nFqh3sU4e+MN38mdRK6daedWu0XsePbzXXTOKx4wiUfXckDQRfzjJ/z1I61qP+0/msKuVwtsV8vZ00VAeDX0UtjSp912TBglgaGieB5TP+P4RGl/WeNIvncrhjwbK9+Q0Dnd/z6CL02+LT07jsLmRwuvlocePjUQ/axaGEsGLwb+7eydzeHCbuX4WAFIYEX18eHqFBcfxeHE/47sPoGz7v53IYXgG0OEC7t3iOffQKRzaXMBfd/jHlncraayplfcD4bwDqeAUqKXiezvBtdcHXqJI526t9QWMBwB7fiko1ga+qxVc/17LG8ZwePVgeG1Fel+usxl8dyuYtGywWQWKtO7mY6ravnMH8/iq1t/mfzeRw5uHGBzrUb7jP84cgeH9sm+wOpa+B63xRhRFn7Ad+DxqDEsXcbTbXNvztq/KTuCJH0Kv7yUnc1iy1XP9lSN4vFspf56RmSIqOj1lU/sG55bxOL3Q0/cu3c6gvn/s+f2JHIb2y2S/fP+obL/rtWUc3jgkLzObVQAmLTvk55Ci9e3pMcgh4q6TeMW4duIgATtbPN+hdw4ROP4FfptmxrBo0NTUhAULFuDo0aMYOnRorIsTNySVJvKiiy7y/T1x4kRMmzYNZWVlePXVV7Fo0SLVaxYvXiw7V11djfHjx+O8887DkCFDIl5mPW7f9FnQNIMHlwDN6qtDRpk9e7ahe5lh1LAS7GmTl2v27NkAgB3H2vH4rm9lx7x4yzFmzGjMPk990NArq9qzjD1uHGafNVL3+gsvvBB3ff+Fz7QpIyMDs2fP0L1v0eASoEn9GYOV0yyMzQE4lXtTtOoPAM6YehJmT/JojV+t/g7oaJOlLR48GGhWTnpOmDAROLRHtRxlo8di9o/KFPfSQwCNQPOd1LQ0wNmrfoEKFM1g9uwL4OYFLPrmc8X52bNno6Xbhbs3r/GUs6wMqK6QnQ9EWv7A82t6d+Hd7bW+cw/tXgu45Jqqs848E4/s3KSahzfvCSdMwOypw1SfqcfF4Q/ffal4Di206tt7jd7z6OG9bvwJEzD71GGq59IzMjF79nTf8WZJXetxzrnnQtzfiLcr9smOjxk7Fqek2rDlo32q1xUUFSPVxmBLk7qGE1A+485P9wM1nr1CM2fOxB83f6VbNhtDGe77Zs+eDdf2GqBcqbUySiT6WbPQNA2eD75ufM455+DBbUrLBy9az8IwbNieOqdOmYIX928H4BnTKYpS3Gva9Bk4aWg2GjqduHfLWgCed17X3oe/7tjkK+Oezw5iTa28H4jUO9BytiO4naBtftNSqQAJAFxnE2y5gyGK/nqbOOFE2JpaQdnTZIKUqfL0tEPk3GCz8hHMfNKWN1QmIHsZNWoUvqr1778744wz8EH9D0CPx/SWovxWJWPKRuG8KeMABB8bpO/hxBNPxPJDu1VS+ctsxLFOdnY2jnYHDwUSWA4A2Ha0DU/8oG3BFYwf/ehHWLJ1HQBg3LjjgcoDsvOZ2dlAp6dsat/gSSeeiNkne+ab26n9eHmjp85nzDgDJ5Rkea777A3ZXtwTTzwJbwTUm+DssUyIVBtXgmGzp2DmrBlAwLg2dsQw7GypBgCMHjMWs88tQ7dTPv4FfpszZ87E6tWrMXPmTNhstnAexRKqq6tjXYS4JKmEyEDS09MxceJEHDx4UDONw+GQbTDv6PB86CzLxkXDDQZFh29NHonnpFVMbrz3sbGs4pja9aGUS+0ahmGC5mUPPE9Rwe+vsg8kUm1G1Ng1oHc/ig7y3Bqbc+RBpAMI4b2ohkoz2WxFsf9ZaXXttM1mA8v6z7EsozivR+B5qcmY55yywKxN3n2abXusYE37UbsmlHz0ykrT8u/Bxmo795Bdx7Cq7YllGF2zPJqmQAfp2wLLKu1zWNbY0Ga0nmw2G2g6dC2kmXtFEqP7sWysue/FStiA8UFtv513fLaxfsHLxtrAsJz82oA2FtF3oOEV1d18VFeL5hUqBUksRJZlQDvUQzsYhetoBADQjlSI/fvpIBr7br0EjuMsy2r23e0tLXC5XJohKaRI34PWeOPzRguAydCObelLHzSFdjmM9hdaSK9X6ydoDRNT33lJ3xvYj3mPU7YU2TUMw8CWO9jvcAnKBYpwCOVboShKtS6lfTndPy+xBYx/gffzzRdttrjoO8NtI8lK0nlnleJ0OrF3714MHjw4eOIEJRFtkZPRgUOkCcXqPNgVIRmyx9j63XB4Nqvvq1Kb4VaFenieGNavzr2tdihD6d8OFCjT9zQSzoGQvMQ6ZJGRb1fUEeKk58ZN8O8jt+WWqCU3DNdWD6HPoznkezs109kLRyqOOVLSdPMOfOR9+9QtC0JBKhwZ6QuSZ2OWOqKrR3GMdqSDzZQL2LFwQuSFotT7XhJaLnkxJVq3t7fj3Xffxfr161FZWYmenh4UFBRg8uTJuOCCCzB9+vTgmUSQ3/3ud7j00ksxfPhwNDQ04M9//jM6Ojpwww03xLRchPgnGQXbYN5Xtc7rVUUo43So3ujMIrtDArxQtUmnKMZn0QOVgkYFPL02GKx9Rroakn3SqUoctq1ApE0r6PcQcC7wnUZSsBRF0fRCh7ux0lA6qTaKdugLcsHQE1ylUAEaNNqRjpyCIgBqpqZqGZgsmMWE86atLHqwNheqd1OKCdTU2QH0gEnPBdcpMaUOEic00gzIfnUAY0gTWVtbi1/84hcYPHgwHnjgAXR3d2PSpEk477zzMHToUHz11VeYOXMmxo8fjxUrVkS6zJocO3YMc+fOxXHHHYerrroKdrsd33zzDUpLld4Lk4YE/GDjcVVKFOVVaWhVOXLFseRewZ5ByyGd3rwopAHCyuDhMWrwas9tKC5f/DX1kAj1OTQnRJSB+ouzukvArjbqWKGxtvSbieJLC5zky4oh8BB5DqJOjEdZXlYVKgxsuYMRSklaW1utL4wBYmnFEbjwoXs+xHsw6fJQMVqLA0IMYmp6oQDSUQ4wDGkiTzrpJFx//fX47rvvMGHCBNU0vb29eO+99/D444/j6NGj+N3vfmdpQY3w5ptvRv2esSbWJjyhkCwT62hWfUjmrEHM+0KKhRYrIc5IGkki681Z1Y4ZMV8zm2fs0Lt3qAs/etpGvfqjKPP3NLsINBCJdNcb9a49iObR6lZAUZSkbYmQPbGg7U1SdJsLBB8vrTc1zfy+zMOHD+uGmghGONcmO/aiMp+jJZqR7NvPKYa735Eh392qMHGNFhRFJeSclBA6hoTI3bt3o6BA6RZaSmpqKubOnYu5c+eisbHRksIREpdEFxQNCS1R7CxDuVOw0FdaE229ybtVgYRDneMb3hMZbvsLnJyGqInUvYVqngET0zgh0JzVqJCmre2mgrZPs5h9H2SqEwEsaLrS/ife3hFlS/E7fBFF2fPqfRPu1hrQ9lTN83z/nkUt2Owi1fAhVmPPHw6uoxFMxiD/vbMKfE56Ro0ahYyiFqDe472bomifRkza57rqD8NeVGZMMy1d7OTccDUdAZ2iHidTj2Dm8XpYuec7km2WoijYckvAd7di+IgyAFsAIKT6ihRk/W5gYWi5RypAdncH9/4UTOAkWEePK3z791e+rgieyCTvb69RHBP6Z41bq/zmLmY0Bu29bpz9N323/S5OaeLx2Z46fLG3Hu9tq8bTXyndmAMqAqHk57eHm7HzWJvyGpWi/+WjPbjqma/DCl6sRluPesDd6rZefLKr1le3UpySgO6t3crwILymraF2OUJ5LqfKOzFNkNtuONgke4e0hZOCVbvr0NSl1CQEfnsj7voIP1S3y47Vtvdpvp+aNmWIk398VY4+tz/fPjePD3bUoK1H+f683PbGVuyukd/3ze+qcMvrm7HpkH+vDMcL+GhnLer7A7fvONqG97b53ZZvrmzFNsm3KaXPLX+HxluBdsrqVu0QL5/8UId3th7TzXljeRP63Dw+3FGD1m6XbBJppHy8IOKDHcp+SiutWh9ghqpmpWOMaGP0W/zZS9+GlH9nX/ix3T7c6X8nTV1OfHtYPXQGAFlftaemQ9begQhopFXsFt3Nx+Bu1m+rACC4tNs7FxAOK7D3YlIzg8ZJNAKbXah7nmLtsA0a4hN4RUD2zBuP9mFXjV/gZXNLQNscYNJysOlQE97bdgyNnf3mlLx2kPhPdvmd5uyv9zv74Xs8/Y8gEaqlAq0eTV3afaQWbl7A/3bWoLHTnKY4kGkP+UNVbK5U9qHbqtp8f6uOoSLwzpZjWPDq99h4qMl/WPT05Rc/td53jHakwTZoCFbvb9Esj7OuHHxPu+Z5kXfD1VgJvsta0+M+N6/uWEfSoF/ZaGy+ebChC3tb429BlSDHtM/aoqIiXHPNNbjppptwxhlnRKJMBBOs2R++1nfJh+oxAa3mna3HcOGEYvzp/eAb9RtVBoST7g8er+ipL5ThXLZVtWH+q5uDXqvWuTd3OTHnhW9U0+dnOBTH/rne00E+qVKOSDDjYc/g9cSck3DlZHkA3BaJ4FipMoHVEkxzUrX39rSoCKOhoCbs6zGqQN+s6mcvfYvfX3Cc73dehj2kcqlxy+tbVI//3zs7Fccu+fsGVD58se/3E194Fi0ev+YkXHWy/P3c9sZWxfXLPj+Izj4O914yHgDw/NrDeOLzA7h6inZw44921uKjnfJ4inet3AUAWLW7Hvv/fCEcLINXNx3Bg//bg0wHix33zcLlT38tu+aDHTX4YEcNDv7lItgY+fri4Sa5pqSu3di+G1YjjEdnH4fXvzmies4o1774LS48oRif7q7DuOJMWZmNyg6/Wb7NULo3v6/Ca5vCK+9ZQRbA4omqltgJvCu3+hc2pj30hWGN9bUvKgXfgkxlH20VrsZKMKlZlnjDpGja0H5JimH94TokMOm54LuDCwQUbW7KJ4oiaEc6KJoBZU/FbW9sDRDMRdjyPLFl3/ze09e9uKESAMD3doDNzFfN95f/8fd9L64/DK6tFhRrh8gpxySjjoVCGZve3nIMi1fuwqB068aLz/ea1xh3OTk88D/lPMzJ8b6+PJCXNugLY1xHI2hHmupeXa6zGSLPgetqBpORq3J1aDR3u4Iu3LT2uFHX3hdUcJ/9940AGFxY04FJpbExzyUEx7Th+fLly9He3o7zzjsPY8eOxcMPP4yaGmOruYSBzcZDzWjvlQ8SWv2NbzXTJJ/8oB2cXA9RBNLsyvhOjSoaKMBj3ucNAqzGiu+rQioHAJkwZJSN5crV+rwgA2OWhrBYmqctsGWmWBOvSaptM8IVk4cETfOhRKt0Qkm2blorNBQVTcZjcm08pHw/hxvVr5cKhM+v8+x/eXtLcE2HFl4t4lf7GgAAnU5OV1Pn5pWT2fEB9ekKSJOTpt4uUlW+KQDITLEm5tanuz0anH11nTjSbF2MtEDWHSBbNGJBuAYdE4bo9wNmEZxy4ZrvNRfcXgujDne0wn3Q9hRDoUAomzmhmqIoT7zhghGw5RR7jkliiFKsf4xhUuXjId/d5vtbFHg468rhrPMImqIowtVYCWddOYS+LgjOHvDdbaraWuk9rMbbr1q1OBoqgfMiL+Famrlboj83N/LJVrf14lCjf2Hy5rNGaaY9UK9v6k2ILaaFyEsvvRTvvPMOampq8Mtf/hLLly9HaWkpLrnkEqxcuRIcF745CyF5UbpgN5bOKOHsbZAKkcFun2JjtM1BEd6+ADsTHacCWoKUmb2eXFcLnHXlcDVUQDThWtzse/JqmYzWK3GsoiScPbyOIG1SS3sdq9dAnDsMDKLp6duMxtHIHjW1uIxeNLtHlUD2nuMsaEca7AUjdO8ZGMYjGN5+VNpfUxQNe8EI2AtGyPKjU5WLqu5WjxDjapBrzbi2Wp9GNdhez4HgZMeK3opJy1Hmq2FSLDUXdtaVa5paC4IArrPJVNs31ueLsjaeZdGiIiH6hPx15uXl4c4778SOHTvw+OOP4/PPP8fVV1+NkpIS/OlPf0JPT+z3fxAIoWJECNHbHxjOCnooE+BYePoURRF8l2dfhijw4DubglwR6fJEJq0VmJnqBnMXbxrRXF5qE/NQhbKYCXMxdtpDiA5B25eF783IvkcAYDPzYcspBpul7RvCXlSmKdDpCoIaApVXO0gx0ZmMUwyruBdtT1GkC9TcAh5hXO04QYmZ5stmqZsOi5xfyyqKok8bLMXdUq04BgDV1dXgu9sMt30gfK/lhMQiZCGyrq4OjzzyCI4//njcdddduPrqq/HFF1/giSeewLvvvosrrrjCwmISkhVND6EJsJ9a38lM6L1kSKE3LLzGcF4BLu353k6NhNZhVCgJlirc82Yx056tD0/ieZpwPNsG9fRrskyJ8H0TEp9YzFWZ9BzP/2nqprRsVoGuJYaeIEhRFGyDhsI2aEjA8eBTOZqN3P5QPQIdvJgRSAjmsOcPVxxzNfm31nBt5rb7NDQ0+P4W3E5wHU3BF9hVTgc2dyJDJg+mhciVK1fi0ksvxfDhw/HGG2/gtttuQ3V1Nf7973/j3HPPxXXXXYc333wTa9asiUBxCYmMaqgHU6kjjfKeeuZSehPrcFbaotXBhqbxlHjANLiPJ1oki2AiNx2LYUEkBJs4mF2QiIQZorTeYrkIQBi4BGoXaYdyf7mWcGkU2p4C2p4Ke0Ep2Iw8XbNY2XWpkQ8DYRs0BEya3KzVGx6EYB6z2zIo1g57UZnm+WAaYMHdJ9NcSnE3HwXf0wZX/SFfWBc1jJQ40Ft5smomn3nmGYwcORIpKSmYMmUK1q9fr5l2w4YNmDFjBvLy8pCamopx48bhiSeeUKR75513MH78eDgcDowfPx7vvvtuJB8hKKaFyJ///OcoKSnB119/je3bt+NXv/oVcnJyZGlGjRqFu+++26oyEpKEaPQTVu2FC6UjlJ0LoxwhaRVVShx0wTBETaQgCOjr64Og4kLczL5IM3jn8Mb3RAY7H91RK1ShKVLFNPv8gU1dubdZa3+tOpEWyqyut2Sd5CQ6wb6raL83Nnew7LdUqGTSsgwLfEagGBuYjFzD+xyNeG8NF9qeCjZLP4yIqfxUhHArife1oVCar5qWO1gcUgA+s1VXU5VvD6Tdru7UyN2o7anayDdn5rkSdX/7ihUrcMcdd+Duu+/Gtm3bcOaZZ+Kiiy5CVZW608X09HT86le/wrp167B3717cc889uOeee/DCCy/40mzatAlz5szBvHnzsGPHDsybNw/XXHMNvv02tJBMVmDagL62thZpafoul1NTU3HfffeFXChC8qKYfGr2D9HtOEKZbOg61gmjLCEJoFEygRUEEdu2ecIiqHkmdDVUwJZbYtgte6yI52HJagHL+57DGYyDmv9qLkhomKuHXBICwTjRnoDSNvm+QCYzD6LAgUnNinlA+GhajmiFIjGL4Iycx2UgvseBcLDlDYO7+ajvN9dWB6Z4NCiK0uyTOYlPA6/jHZdLXSupt1is/s3Je3xRTNyFuc7OTnR0+Oc+DocDDofSVPzxxx/H/PnzsWDBAgDAsmXLsGrVKjz77LN46KGHFOknT56MyZMn+36PGDECK1euxPr163HzzTf78pg5cyYWL14MAFi8eDHWrl2LZcuWYfny5ZY+p1FMayIzMzNldtJempubwTDmPH8RBhbq5qzW9iTheGeVYqSD03WsE65vepOE4lhHW3ukfWVfV3CX9l6PfPFMPA9glguRFtzfanPWSJOoq9cEa4n1d07RjGdRzaQAGc7wQdtTQ7/YIuwFI1S9hQbDljcsLsqf6NA2hy9+pxdRFAxboBhZAND07m7gFuFYasWa8ePHIzs72/dPTSB0uVzYsmULZs2aJTs+a9YsbNy40dB9tm3bho0bN+Lss8/2Hdu0aZMizwsuuMBwnpHAtCZSq+E4nU5N1TfBPMkYomDltmqs3Cb3AnbcPZ+qpv18bwMe+2w/fjvLXMzE8obQYgod/yd5ObzBtrU6ux4Xj7+t2q+ZX0df6Kuwevlq8e62apx3vNyM6MH/7cH8M7TNp9p7zZfxtdXf46IRp+GP7/5g+BpR4MG11oBOyfQ5ndCKi6XF7poOXPDEOuyv13bew8lmXvL39sa3Vbj2NL/Tga1btvi81DmKR+P1b45g3umlGHHXR6bKpYZa/MgVm4/i9vPH4Jf/2YqfTx+hG/fyaEsvqpp78OvlW9FrMp6mGlc+8zVumjES3xxu8R2b99J3mukXvLoZY4syce8l433HekOMV3buo2sC3ouHtRGIuyhtU9Me+tLSvD/bYz6AeDLzu7d2xPT+Vzz9NQBgdKG2cHblM19jVL78/HUvfhPS/QS3fmD0ULEXjICrsVJx/NKnN4Wcp9TpjponTjP8+aO9IV/LZuWD72nTTeMoHi0rI21zAOm5vpATkQ7vseVI5E18w+E/32ibjQYjML6mYMLxHUUzGHHXR7hvmtLjrheRc6nGHZ3+sLLvfTMgbvZ1L36LOVP9Qu5jqw/gfzvVnf6EM5eKBHv27MGQIf5vTE0L2dTUBJ7nUVRUJDteVFSEuro63fyHDh2KxsZGcByHJUuW+DSZgMehaSh5RhLDQuRTTz0FwKPpefHFF5GR4e+ceZ7HunXrMG7cOOtLOEA5GKIwlEz8/ctynxBZ32E8TpFVdPa5seFgbMNWmOFXb2yDnaXh4vxmS/UdfSjKUh8I9taqaxXV5GZX/WHfZvrF7+xCZYt/gz6bmS8zhQnE3XwMIu+G4HaCSc/xhAbpaARlcxh2MvHO1uAe/fQWXv747i6fECmKokJTde97P2De6aX95wVw7Q2gHekQetoguJ1gs4vApGYaKuu5j65RPb7kg93YcbQNd6zYritEAsDid3dixzHlntNQONLcg/s+2C07tulws2b69QebsP5gk0yIDLU/UhMgAWDjIe37E+Ifb5D2WKO3aLitqg3bqtpkx74uD63dcW3BJ2mhhNdQhMmI8B7AeMKWUwwAYDPywHU1g+3/LYWK820RkebzvUqrP6MEWmWZCcHlNVfVWyw2I+CrDc0rNh+V/dZaIOb4+FKoZGZmIitLGRNVjcB3IIpiUGu59evXo6urC9988w3uuusujB49GnPnzg0rz0hiuNfzegkSRRHPPfeczHTVbrdjxIgReO6556wv4QAl3j6cWKMfTiMyiABcfHx5IA3GjLI8fLXfr+Wxot5EgZd5Y+vok2sR6ZQM2GwOzVhTgQGPuZZqz8b93vA9FcrKIfXOqes5Vy5CuluqIbh6sWXLFoicG1x7HQS3UxaQmWuvNyxEatFpYkXVTNpYM/fUYdh+tB3VbeoBqwnJycj8dFWte1ISxGGYLafYkj2PerElw85bRUiLNI7i0RBcvaAYm0Lj6q0vJiMXdGqmX6CW9OOCAYcwBGOoLbJSNKO6v1Ho65JpiCmGhS1vGFwNiegLCwAAhulJREFUFREtoxo2JvF20Ofn54NhGIWGsKGhQaFJDGTkSI/12MSJE1FfX48lS5b4hMji4uKQ8owkhpcSKioqUFFRgbPPPhs7duzw/a6oqMD+/fuxatUqnHbaaZEs64CCuJSXE4n6ENxO8D3tUXH+wfe0+zyeRRNLRG8Nhwz2ghGw55eCYljFPhatjfci55LVg6uxEoK7D3x3m67bcCMYfVYh4Hm8plMA4Go6omm6Fq6jiOTapyd/FtJdEZKZwL7JK/Cw2UUh7XnUIhRtph5spj8APRMjxz60PRUUw+ouwkmfm2Js0SgWAYCtYISxdLlDQNEM7AWlkqMhhAjj3JaM9fGO3W7HlClTsHr1atnx1atXY/r06YbzEUURTqd/PjJt2jRFnp999pmpPK3GdI/11VdfAfDY/NrtdsNqXYI5iBAZebjWaoiCAJaiwKSqt+Nw3oMoihCd3R7zyP5YWY7i0aFnaOSeKmUwnUfAJVyH0qSGYljFhMc2aCjcLR4zN1dDheqzBgpoIs/5gk/Trh7YcktMl9dfbkkMS510gUKkUVyNlWG9vyTc5gzA81x0ZLcuEQhxhS23BCLPxb0XajotGzaGBWXT3tsWLYLFKPRitSBN0MaoGSTFegR7qYDP97Sb1py7m6sgiiIYgZMtcCQjixYtwrx58zB16lRMmzYNL7zwAqqqqnDrrbcC8HhWra6uxmuvvQYAePrppzF8+HDftsANGzbg0Ucfxa9//WtfnrfffjvOOuss/PWvf8Xll1+O999/H59//jk2bNgQ/Qfsx9TX2tbWhrvvvhsrVqxAa6tnQ3JBQQF+/vOf49577w0a+oNgnEgE4ybI8bo859obtIXIUOP7cW7wfZ3gu1pkxwW30+M8IEpYIbhINXVe2GwV0yg1r54BGkmuXdtBidFJRrh0dnbGRKBLUhkSokj6K8LAgmLtCscl8QhFUaBiHFrESygxhJk0oqSwGtqeCpHnwGTkhpWPmhApigLAc5rfhnehV+jrhmBLAeVIi7jzpFgxZ84cNDc344EHHkBtbS0mTJiAjz/+GKWlHm1ubW2tLGakIAhYvHgxKioqwLIsysrK8PDDD+OWW27xpZk+fTrefPNN3HPPPbj33ntRVlaGFStWxNQK1LAQ2dLSgmnTpqG6uhrXXXcdjj/+eIiiiL179+Lvf/87Vq9ejQ0bNmDHjh349ttv8Zvf/CaS5U56vAtEosAbDiZMMIZWnap1gKFoIkWeg6tJ3auau/ko2Mx8j4OZCLxbvTicRu9nxOyStitXtgNjpAEIupdIce8otPfe3l6EKtIJzh5Q9tTQNrKbuGWiiWTEcoIwUPB6mLYKr4dWNiPP0nzjGaOCA8XEv6BuCRFa1WTSssH3BDhoE4UAs1TrcDcfg8i5wGbmg05JB2jWN1aKnN83gsi74e53VhXMuieWTmPCZeHChVi4cKHquVdeeUX2+9e//rVM66jF1VdfjauvvtqK4lmCYSHygQcegN1ux6FDhxSbOB944AHMmjUL8+bNw2effebz5EoIHQoA39flCRKbnpP0qv9gWKXp4LvbwHU2qToZcNUfBuB3kkBRod1V5PTdwXOdTRAFDnx3G9isAkudyyjK0i+5uNvqIPR1wTZoqKoAqHm9yt4FI8MdFaJ9o6uhwrPHKAQzMVmAD51C0jStOG/UTNUbAzPSZsmJhAgx4YReAiFUrNr/6IVi2AHRn1AU7RtPbEGEGDa7EIKzB3QEx8a4IkKCEkWrTPHVjulgZH7i9RAqci4AnjkO+r3BOopHQ3A74W4+qnpttK2zCNZieKb33nvv4dFHH1X1AlRcXIxHHnkE77zzDhYtWoQbbrjB0kIOVPj+fXR8d1tsCxIHWNXHekNR8O3yfX5SUxvvClldbS2OHvgBzrpyOOvKIbiMOsYJXljvO/XulbQK5Z5Iz/9eL3fulmPgg8SL8l7jrCv3CdZSjLwKr6mwGML+Q3drTUimT0bp6FAPbZKdrT5Y2vOVEx69vabutjq4GisVArgZxzrxYPqq94yKUwm8WhwuoijA1Vjp6zcISU6YDrYGKra8oQA8C4zBrE2Y1CzYcooTWgsVD6iFSBFd8m0jepp1W+5ghclqoFDpmScc0oxJKjh7IARqQyUEbvkhJBaGlyRqa2txwgknaJ6fMGECaJrGfffdZ0nBBjpW9Z2uxkqIPOfxoskmntezXhePbUdbMSLP2vhZgRN8vssfdJhJ9+wVeO2LbQGhII7F/Yrx0Rb5AKEmBgQLV7H8uyrV40xqFgRnN7oyhhrXPAmhTbiE3g7fe/AdczvBtdeDzcxTjad2uNEfbkBQEYDueHMbpowYBDTWYER+useBgyD4VrvfPugvq71ghK6DB5Fzajqr8ArsrvrDsvbyfaW/jQWLs7fTohiR4XDjy99rnmvvlZgmiYDTHTmhP95xN1VB5DmIvLFwBKIogmutAcU6wGYlroXJgAnvEQAV4ImaYAyKtcf9+DkQsOUN0zxHp2RA6OsCRVGwF5WppmHScsD3tHs0ywHhu9TwWu9oITj1+xGyjBDfGBYi8/PzUVlZiaFDh6qer6ioQGFhoWUFI1CWaGO8YQlcTUcSsgO/+fXNWH+wCZeeFLrXTiPwPW2+v72mmP9cX4FxxXLTJa6rBWzGIN28gpmzRpLAiV0o3lmXf3cEXLvSIyubbf77lu6DMAPFKs1bvOYw7tbaoG155ValkPbe9hq8t70GzrpyvHnz6YAowFY40rfa/dzaQ3AUj1YN3hsYT4tvb4Sbc4JibKAd6eB72mDLLVEs1DjrylXL+ru3duiWPx5Ye0CuJe9xcUize4aM+a9u9h0XATR0xq7Nxxpp6BeuvR5stn7MLqGvy+OsytWb0ELkQIX4KCAkKvaiMqV2VzJHsOUUBw9e7zslKvdbhohXi2kbNEQRLoxNwDiRAwnD5qwXXngh7r77brhcLsU5p9OJe++9FxdeeKGlhRvIaH3DfG+nT2sm8hy4jkZZ2ARX4xG4mzyT7VjEJbSa9Qc95qcf7tBfzbIS6eravjq5dsGI6QXX2Wx5mUIlFLNIvrPFsiDPIu/pL0x7YJNoirnOZsV+Cr6rFc66cs2V0A802otvwi/Ct+81ELVjTIBJj9C/UCDybt8ChLu1Bq5GpUOlaHmdjTQdvdpa5XOO89fP/DNGRqM4cQnf2xn0fUs9FKv10VxnU9DVeQKBQAhOQDxflbEtUFkR3IS431GOKFq+1crdUq04lm4nIV/iGcNv5/7778fUqVMxZswY3Hbbbb5YJnv27MEzzzwDp9Ppi3dCiAyiwPsnIKwNfEcDREEA39MOe1EZRM4FkXdD9KZV2aMjOLsBUbTcOUByod+JCn1dmvUXGA7DljcMFE2rChfRQBRF9PQoJ7Xu1loIzm6wOcWKINSiSkgPJi3H/L15t2//pZqDHnt+KfjeDvDdrYpzXEcD7CkZEJw96ue7PIK6q1Fdw66tgPWfYNKMuzhnUjJA5Q3TdA6gh7u1JiGtAIwiivBV6x9nj8PNZ5XhpQ0VMS1TLPFOykRRhNDTDtqRpu3ynnOBdzvBdTTCXlAK0e0E390GvrstqdsMgUDwEyldmzSuoxamF4wN7LWy5RRr7hG3F44EBAFgWLjqDynOi5xbZtETijUVIXoYFiKHDh2KTZs2YeHChVi8eLHvxVIUhZkzZ+If//gHhg8fHrGCDjQoePYQeL1dAR7PlV4CBUSuvV6uvWmrk5lZAX5vr4DnQx5oZjmB9aGXTs8M091Wp1l/gStpXq9jbE6xqlAfaUQRKC9Xbnj3ajq4tjrQRWUQnd2gbA5QjM2nZfNCO9LAZOqb8HphUjN9gqO7Sb63ks3I8wl/gCeAMZMxCLQ9Be7WWnm5BQGuxiOG9lyooTXuCL3+AdPsHuFgHuRoe6pqTM1kQcsxkPQ4iRcJCD3tYFIzIfS0eawSOrW9+UrNxl2NRwa8F+54JFSTfALBKHTEvLMGn+NJveZaAZtdqKukoGgG0ClX4NYrgciQcY0pPfHIkSPxySefoLW1FQcPHgQAjB49GoMGGZtgEozD87xMgAxG4GqS2mRWKsTwXS1gMvMHlPezQKFGC8HZDTGIW2vB2Q06JVNWf/FggiYKPESe8wk8IgC3W38SxLXXe7SrthSfBz0pbM5gw+2EycyXaB9Fn2DFpOeAUhHCKIoC5Uj3xUqTPUuIAiSg7lgHgEyIDQUmLQt8j7p3Vz1HPGYROTdgwIthvDCQxnnB7QTFsJrvxmuiKu2D3W11sKmEFQrEa/5NiA9EgYfgSg5zdAJBDSYrX9UHghZa/Z4tbyhEtxNMapbmtYGezm25JaqOd0SB92gkbQ5TXs0J0SekWU9ubi5OPfVUq8tCkOBW2XtqJXxPO4TeDp8HLlEUAd6taXaVDJhabQuSlmtvAOPqA52a5Yu7GKhNk67GqcZrshhRFH3aao+TFzs4LrhzJu8ChNr+LIpmTC00BA4w3ok0RbOyOmUCnBNRDAs2u0i2X8xqrNjnyWTkaQqR0hAwFMPKNN+iwBsWCEWeg6vpiK6HvLhCMsYn+5qU4Or1WRvomZuKoihThxtte9K2ZabNECKDu7GSmNMRIk40BCU2I0/1OJOaBZFzKxzamIFJzwVtSwE0PJZ77xNo/UM70uAoHq0ID+KdxzBpWUQTGecY8nZx66234uhRY3uBVqxYgf/85z9hFYoAcAGml1aaG/jzFH0DpKv+EFxNVX6nPUk2cBqP8ehBas9PO9LAZAyCLXewLA3f2wF3yzHVWIoAZPGVaHsKmLQsT3iKAI2cGY2zHlyL3yMp11YLV2MlKg4dlKWx5ep7uQ1cFbRqUUFw9crMwtQCGOuFHTGLWuuVvtNQB229Sb1Uc8pk5sM2yK/VDTSJ0/u+vBYDomid97tIk2z9hRacZKGI62zS3PfDtRzTNG02OllLFodMicxAadeE2BKVZsZoj12esFnKmJJGMeI4T2/7iKN4tOrchO/pgECkyLjGkHqkoKAAEyZMwPTp03HZZZdh6tSpKCkpQUpKClpbW7Fnzx5s2LABb775JoYMGYIXXngh0uVOeuwO+YpOpCYUortPFveK62oGaBp8ZxPYnMFhdSzxBNeuPtlj0nPBZuaB62jQ1DCxmQW6HaCagE870hQCB5tV6Lun17ENAAh93WAywhfWpF56vZOf3t4eIN2jETWyDzawndE6pimmyta/5zIYgaE0FOcD9glrEWzyN/a444EPNwTNRw1bbgn4zmYwWQVwtyhDiQAezatXQ+0pkL+NeFddtWK3SjXCXEejqsAdTwykIV76ret5JpR+iwBk/ajH2UXwvbOCs9vShRVC+LCZ6tocAiFeYdJzIbr7QKdEri+hU5Rxm5n0XJlTvGB7i7Xmmk211QAGrsfvSFFeXo5Dhw7hrLPOQmpqavDQLhoY0kQ++OCDOHjwIM466yw899xzOP300zF8+HAUFhbiuOOOw/XXX4/Dhw/jxRdfxKZNmzBx4kTTBSHIsdnkk0s1pyymwyaowHU0KiblXEcjRFEMGiQ2GfBO0NmsQk3zNLMOWAAEdZDBZEg8g4ZoAij0dcHVeASCu09TU+1dxKNZh0+AZFKzQDGsbtBhwCPQqQ0OoUAxNpkwpCXMsrmDfXE6ZcezCjyrlSp7NtUIXLyUmsvQKRlISQ3ddId2pMGWPwy0PUWmbZSlscsXgfjeDgjOHtm+T3dbLZIBUSS7VoIh3S/L96ovVgUSzJETIfow6cY9OhMI8QCbmQfboCGR9X+h4gU2sP8KdW9xR3vwsGoE4zQ3N+P888/H2LFjMXv2bNTWeuYhCxYswG9/+1vT+RneqFVYWIjFixdj8eLFaGtrw5EjR9Db24v8/HyUlakEMCVEHEtMXHkOLoMOZxIZNc+stD3VMmcoUiGFYtigZqAUK+lgQ9z35DWlczcfU+wx9HL7m9sByE1F2exC39/ePXdqrrbthaGt/jHpOQotDZtTDIpmgoYtoG0psBeOguDug7tZouUTvG1dJc6VKCgWVLj2BvC9HbDlDfXs1ZCWJTMfJz+42vDz6JbXngJb7mDFfthAhL4uxb44I+7XAY8pdqBQGgumPfSl6vH3ttf44kSScUAd0dUfV9SE3Rrf1UKEFgJhAPDievUtMYkAbXOo9/sBYzLtCG1B+vuW2I99ycSdd94JlmVRVVWF448/3nd8zpw5uPPOO/HYY4+Zyi8kVVZOTg5OOukknH766Rg9ejSZOESIUD+6QAKFAXuB30MWlSTmqpEilFhtXrNVPSiK8u+N0jHfNArfpb9aR2nsw6IoyuPAJUSBUQ02M1+Rn1mtikeYHOnrW7xOitT6GjWnJV5tj7v5mHI/rNXOSkLMz6g3Xy2T2Xhizf7GWBch5mgt5HhOetqIGedOZD8egTAw6HaFPweIFayGNU7gRgcmPSdoXoGLZvb8UpwzgYQOtJLPPvsMf/3rXzF0qPy9jRkzBkeOmI9nHr49JCFisDnFIWnKArUyCtNBmvW5YbbCY2WyorYXzV5UBjolQ+Y0JxDDoSki4CxJC4oJohmlGd3YTqbvRzO+PQ5MWmj7Kimaga1ghGLvoL1wpGwhJFAIV+wfDqhnqxe99DzvBhs4Ax3naO0HjYRjrUgwkJcT9fpS0bfP1bhgGI63RIL1GJkEEwgDDc3xNHAeasDyhs3Mk20Folgbrpg8WOcKglm6u7uRlqZUHjU1NcHhML+FggiRcQxFUbDlB1+FCZyk0ykZPk9XavveKIoyvC8nWdByb60HreLUgqIo2HKKwaRlawqSRhzI9KcEoNQ4iJxboaVSO6YGm1UANqcYTGombHlDYc8fDltuiSFzSFtOsWe/JEXBXjDC4DPolCWnGLbcwWAytQXuYFA0o9iTStGMbEDyCl5CXxdEzq3Yy8t1+LVkMuHTIvQWevScrwDq8VzVEE16FyZEH712IArmFwGsskQhhEbgwg0Jt0IgyGHScqzPMz0HttwS2AtKkcKIGJZLrOWs5KyzzsJrr73m+01RFARBwN/+9jece+65pvOLfPA6QlgYcZ7DZOSBYuyewKycC3RKhqH9ZwOJUDQ5gXvpAlFbWWPScoJe58XrhZPvagErMYVzNXlMCmy5JT5tnvcYxbAec1mNCY1PeyqNUWkiTAebXQhkBzfHNQJF0aCiMBGmaBaCs0cz3IJUM2x0H2K0UGivNEwYDWu3Y0w87WwQec7j4dRC77YURWmambKZ+XA5tfeXC65eCH3GTJgB9X3chCgS8J6TOYYygWAGe0EpBGeP6kK7l3D6L++8hyIu2yznb3/7G8455xxs3rwZLpcLf/jDH7B79260tLTg66+/Np0f0UTGKVrbYRiVkAsUzYBJzwFtTwWTlk1WTFVQm4SraQ7s+R5NlZ65qhfakSYTSjxmrvpeWYMhnaB6NWpS80yR5+BurYG7WRm3NVgMyGTFIyzE1ixb7bsEjHtzFHm3xyuyhrAoup1EqDCJq7ESXEej5uJCKOgtilCsXdcrs7ulWtOagGaV1gukH48faEc60QwTCP14va3rKTmsin9NsJbx48dj586dOPXUUzFz5kx0d3fjqquuwrZt21BWVmY6P6KJTDQCBB+jEw02qwBcRyNsuR77cja7EFx7Q9Dr+K5WMBm5IceQiRe8YSPolAwwqVngezvAqEz4KNZmSoMbjnkk7UjzrOZJnRsFaEylXl/1CDdYcCLD97QZSmdUQxwSksFUagrMZPhjZbGZ+eA6mxSX8l2tnvisUO6R9KXp7fC02bQsQ46bYkW89BBSM2FL931rrO55tZ1Meo7qOw4GO6gEroYK+a3IKnxMkS7oeMdNAoFgDCtC0MXLeJJsFBcX4/7777ckL9Nvub6+HvPmzUNJSQlYlgXDMLJ/8cAzzzyDkSNHIiUlBVOmTMH69etjXSTLoAI+K73A7FKYtGw4ikf7VlONBp7luprBdbXA3XBYEUA7kfC62KdtDk+cv/6QE7HEG+ZDZmJp0lMrk5YDR/FoEgrAAIwB7bIVSDXcFEXDUTy6/x3lqKb3CpCBqAU253viey9zvCw0SffBWoXg7NHWJIa7gKNWb8Q7a0wJtp+ZQCBoo2fqSogdL7/8Mt566y3F8bfeeguvvvqq6fxMayJvvPFGVFVV4d5778XgwYPjZtLgZcWKFbjjjjvwzDPPYMaMGXj++edx0UUXYc+ePRg+PAlcBVtU32bemzd8hLv5aOLus2RtAOc0LHRHA+9KN9/TDiZjECiaMb13k8nUCStAkBEPe5rYnGLwHQ1gs4sVDoACYdJzPfvoAr3NEoISCVMqvfdF2cO1AiBCZLxBPJcTCGFgxVw1vsSLpODhhx/Gc889pzheWFiIm2++GTfccIOp/EwLkRs2bMD69esxadIks5dGhccffxzz58/HggULAADLli3DqlWr8Oyzz+Khhx6KcemM0yuJG+Q1RQU8qzu0s9uwV0ejUIzNkPMOZ125x3tnkXnb6ZjSL5zFk2MV6STF3XwU9oIRple/rTAZGSjEw4IXk5IBxkQoFYp1AAFCpKv+MOxFowAA7tZaCM5u2POHx4WQHAdVHHXY7EJZ27LllgRdIAA8XrW9mmW1tinyZE9RrIinxUYCISGRzE1CDVc0AIeTiHPkyBGMHKmMC15aWoqqKm3HcFqYFiKHDRsWt0GQXS4XtmzZgrvuukt2fNasWdi4caPqNU6nE06n30yzs7MTAMBxHNzu2HlEbOr0C4lMWrbHDJWiQNEM2OwiuBorw76Ho3g0RM7zjBRrM7z/ThRFOOvKE0sr6W2zcTrLFXkOgqsPogmtUzwIDfEERdOqoRQomoa9cFRE702nZIDvabNskcLnxEOlrxVFwbeX1mte6Wqqiovvkef5mPabWogCHzHz9cC9tkZNW5mMPJl5Mm1PheDqBUXREEUhpBjBBGsw4i+AQCBoI10YC1XpIQJxM55wXHI4tissLMTOnTsxYsQI2fEdO3YgL898KDzTo9SyZctw11134fnnn1cUItY0NTWB53kUFRXJjhcVFaGuTt1D30MPPaS6wfSLL75Afn54njbDoakPkL4e2T4rCycXgTH4/MftSeNdSxQFfycWx5o7d8uxoGnsBaUAzUJ0dkclfEY8Q9scsn26TEaePCZkURlEV09UvCrS9hSPZ18T+8IphtX0uMr2h1nRchrkbq1RCI1cRyNEVx9s+crYsNFi9+7d+Lj5B8TaZxuTmgm+t9P329VQYVjI5ns7QNGM4XYj8pzmgo5XIFQ9RzMeJ0z9ky02twTgOY8Tpe5WiAm8Bz3RMRKTl0AgGIM2YX0jhReA1atXW1ya0GhqMu8wLR756U9/it/85jfIzMzEWWedBQBYu3Ytbr/9dvz0pz81nZ/pkX7OnDno6elBWVkZ0tLSYLPJhZCWlhbThbCaQNMgPc+iixcvxqJFi3y/q6urMX78eJx33nkYMmRIRMsZjAe3fRY0TahmAmqwOcXgTLjDFzm3phAaT/CdkjYZQrzISEGnZJjed+PVdFFBOuXSQWk40pLse+nkJoSUzQFIhEiKoqIqaJv9FmhHuqY31lC0Zt68uM5mVac8kUTo6wIYFhNOmITZpw3H7Zs+k50TXL1gMvOiZn7ttbAI5TqvFkpP6PR6eAYA0Mpn8m4PoFMy/OlUkDthogDWBqH/PSayIzMCgUCw5w8H39sZ8ngkApg5c6ZCzogF1dXVsS6CJfz5z3/GkSNHcN5554FlPeOPIAi4/vrrsXTpUtP5haSJjFfy8/PBMIxC69jQ0KDQTnpxOBxwOPwxujo6PAM+y7Jx0XCDEeoKjxpMSgaQXQiKtUPo7QQfRBPpbj7q25sVz4huvylFrD2ySmGzCuAKIkRSrB22QUMg9HWZetc0HZ9mu1ZC2RyAuw+Ax4RQamavFbcxnmAyBmkKkUbQDAfS3QomPSdqbV1w9fliMTLsVPA8D5F3ewQpgfedE/q6YCsYAYqiIAqeNJEIuyKKIoT+dmEWgfMLbiLPqVp9sJn5oBjWJxyqmTDbBg2B4Oz2eCikKMW70o2vFkcLXQQCgRAqnti5oS9oCiJgs9niYi7uFbgSHbvdjhUrVuDBBx/Ejh07kJqaiokTJ6K0NLRwdaZrxaznnmhit9sxZcoUrF69GldeeaXv+OrVq3H55ZfHsGTWYxs0BIKrF7TFk2Xv5Ft0BZ+ExctkRxQFQBR1Js1+gUptz1ysoGhGVxvJpOeASc8FRTO+OHSG87aigHEOk5kHULRPuJZaG2iF04gnAturd08cbXPI0mg5+dAzuePa6mAbFBlLikDhSnD6229neyt2726Cq/GIbM814NmXyLXVwpZbAq6lBgLn1HUIxPd1gXakm3aIxGuETDGCKNm7I31O6TdKMSxA6w+dFMP6v1mVfslWqHRsQCAQCAQ/8TNbSz7Gjh2LsWPHhp1PSKI1z/N47733sHfvXlAUhfHjx+Oyyy6LiziRixYtwrx58zB16lRMmzYNL7zwAqqqqnDrrbfGumiWQttTLTVlVeSflg2EEDQ7FrjqDwMA7EWjVFf4pVqJeNvnacsphigKvmeQwmaGvic3Tv0HWQpF0YpVTjYzz+NEJQGdDrFZBeC6WmQxP9msAp8mLxC90B9We2/24m6rg9DXBTanWCLg+Rtbc+0xIN8TmF0URcWeTsHZA66zyafxE5zdYFTelavhsG/Bx6zDoFDj+3kcFqkL5rI8KQq03aNBpWg6qMZXGtuXSc8J67smEAiEgUKc+vBMOBYtWoQHH3wQ6enpsu17ajz++OOm8jYtRJaXl2P27Nmorq7GcccdB1EUceDAAQwbNgwfffQRyspiG/phzpw5aG5uxgMPPIDa2lpMmDABH3/8cciq2oGK0dV/vf2m0UBqwii6+kAF9YwYf70SRdGgHemyCawtd3CYeQ4AKVIFqQCWCHid61A07TFdzimWJwgQUOz5pXA1HYliCeV4NXLevdNsdhH47lb1xKKgqmWXCmRcZ7PqO5NaDFjVx+jtFRV5N1yNAfUq+J0eyRaiTAq3oijRJJPQEXEPCe9BIMQH4oCwqYo827Zt83m53bp1q+Z4Gso4a1qI/M1vfoOysjJ88803GDTIE+i8ubkZP/vZz/Cb3/wGH330kelCWM3ChQuxcOHCWBcj4aFTMgDerevgwd1QAcrmiJjpXCCCsxvu1lpQjM3jqVRiUst3twZ1r89kDIp0EUOCzcyDSyJEhutRlHS9iQGbVQiuvd7njTUY8ebIimuvl/2WjUEGJ+Mi55Jpjt2ttbLzfGcT2KyCkMvoy6e7VVOI5DqUVhd8V6vqPmTR1QukZhq+r2zPZBAzWELsESRefYH4HTMIBALBCF999ZXv7zVr1liat2lXeWvXrsUjjzziEyABIC8vDw8//DDWrl1raeEIscWWUwxb3jBdhy7e8BmR9iTI93bCWVfum2CKvBuiKMLd4veYZcTxTLS8Q5ol3A3ogdADVBOZaNCONNgLR2ouGhg1S3UUj1Y4gXHWlVsa05czad6u55VUirvZE9qGa6/3mLoGmJTyPe1w1pWH9Dy2vKHGEqp8L9I931Ihl04xucAjyVtTa0uIG6Qm2GxmHlgiRBIIhCSA4ziwLIsffvjBsjxNz6gdDgc6OzsVx7u6umC3J94+JIIBjGgUImwCFKjxAAChp02+x1EQwLXXywRaKyfRkYZJz4W9cKQlQePdPNmSngwY8V7qdeDCpOUozgl9yr46FERRNLTXULr/z+jeRFEU4KwrB9/bGfQavks/hJR0UYnNyAPFOmTntfaRqu6hlZihyvoZs15veXN9Y7TDsxDkyHwNxOmiI4FAIJiFZVmUlpaCNzkm6WG6h7zkkktw880349tvv4UoihBFEd988w1uvfVWXHbZZZYVjBA/BE7E7CqeBUUu+jHNhF75fiuuqxl8byfczUf9aUzGYYw1VoVlONxEgmVHipJs68NSaCHVLnrD6diL5PvOveEj1ExdQw1Y76o/DGdduW8vIN+p7/GUScuBvXAkcvKMmeWGip4mT3B2yzW3rA0URclM3LU8SquF6RAFAe7WGsU91dLqljnAuVBwiBVBTJEIjlQEQtAQCARCrLjnnnuwePFitLToL8gaxfQGjaeeego33HADpk2b5ovdwnEcLrvsMjz55JOWFIoQX1A2+Sq9mqCj5SDDCjRDHBgQXMNx90+ILQWZDjR2xl/A9fd+NQOrfqjDrup2nHd8EW55fUvkbib71jzCBUVRYNJzfcKNV3OiJtzwPe2m9xMK7j6fsOVuPgZ7wQiFIGTLLQHX0QCR9zifYbM8HkcHFRYBaFTN114wAq7GSsXxf88/Fe9sPYZet4B0G4N3tukHdRacPTLBkOtshsi5lJ5VfWUr9N1X6O3wxMMNREO4FJw9Cu2l2YUeaf9lxGuwKHHoQ4gcYwozcLBBxfGTJKanNNwOYWAxYUgWfqg2ZpJPICQKTz31FMrLy1FSUoLS0lKkp8u3Z2zdutVUfqaFyJycHLz//vs4ePAg9u3bB1EUMX78eIweHb4JHiFOkZiE2nJLon57V0OF6WsEV69nci2ZHNrzh1tZLEKEKclOiUshMivFhnnTRgAAqtsiE0rDC0Uzvm9O5jlNYmrpFRK93l1FUZSZfwc6rgmGd4+il0DBzxtKxzZoKARnN2gDTmbYjDyZVpViWNjyS+GqP4ScNDvmn+HRslY0dfmESNrmUN1r7W6tgb1wpCeGJufS1E5SXgFAWm8aC1Jch7rgawXSWJ+RDMtEMAfZNk7Q4xdnjsLtb26PdTEIBEu54oorQFGUZVu9QnYVN2bMGIwZM8aSQhASByrKK7NeTYdZ3C3VnmDnklABMGmGRogtibCbNRrzUFWPw5RfGyZ3+uLRskmFSFdTlWYM1VDw5kMxrG8/pu+cxjVeQdM2aCgEVw+Y9FxVd+LSPZW2vGFw1pUDAJjUTPBSr5kCD9AMRN6tXkaa8QtskvtQYXo9DgUmY5BPSGUM7HcMpukUeQ6gmQEbxiccRFEEBF7hhIpAIBCSmZ6eHvz+97/He++9B7fbjfPOOw9///vfkZ8fXtxiQz1pJANVEhKM/gkkk5ajMHEzq/EIhijwquZvhq8PWGkhky5CssBm5nlC2hhd1BF4gAkuRHJBHNcYobi4WHmw/9uj7Smg7f59ZlJT20mTJqHqi69ll0mdTEmFSJF3g2Lt8kUiCdJ921Lh2ao9x2agU7PAuJ2gHGmGBHk6JRPQ2IMquPvgbj4GirHBlj8cgBi3HqdjgSiKgCjI3rMo8L7f7qYjEHmu32tvcG/eBAKBkAzcd999eOWVV3DdddchNTUVb7zxBn75y1/irbfeCitfQ0KkNFDltm3bwrohIfGQah+9ghiTOUghRLqaqmDPL7Uslp3Qo9yPQNtTQTGsXCuhhcY+J0JikAiOdWO5LmGFF99Agnk/ZTP0NWkUBQwePNj3m0nL8hzXEN7o1Czk5uYiNTUVDMMgv9DjmMeWO1g1vRd3ay3Y7EJw7Q3y/FIyVLVMtD0VgqsXXEejQntqhlDM+SmKMhwHtP8C358i75btdfU6ExN5N1z1hzxlyhtqyItvsiOKAlz1h32/HcWjfZpse/5wuJqqfOfczccgFIfeDggEAiGRWLlyJV566SX89Kc/BQBcd911mDFjBnieB8OEvrhqSIiUBqqU/k0YIKhM5rVWv/nuVnMTJh24AKc49vzhPk2n0Net6WnRS6J5ZiUkBgmp0BZF34TaljtYMy6lFHtRmU9Q8cJkBHeeRdO0YQGXoiiMGjXK93vo0GGGrw0UIAFPbFs1pF5buY4GCM4en6m8vWCEPI+8YTIPz7LyRnlPI9/VAja7SHJE2edx7Q1kvze0w7cAkAmQXpxdbQDIHlUCgZD8HD16FGeeeabv96mnngqWZVFTU4Nhw4aFnK9pO5ibbrpJNU5kd3c3brrpppALQohfKJsdFE2DZoObzhkNMG4EOsCLotRUVqodVd0zhsg6yyBEHjFOd0VK9+1RcRqOIdAjq0wL01qr6rAmkEDzb4oOPlyEWx+0zuW2QUPCytsL39Mh22vtbpYLGHomwlExiZcujgUs1vEq1hmyGJYEH8EcR/B92kIngUAgJBM8z8Nul283Y1kWHBeeN3DTu8tfffVVPPzww8jMlHvk6+3txWuvvYZ//etfYRWIEH9QFA1bwUhDE6hAwS8caJtDU5vIZAyC0FINOiXDk05nFRrQFjQJhGSEScvWXUTxatrolAxV7Z1XU+l1aGNUexmuTE3r9DHBPJsaKp8K0n2V4Zi6WgYtGZb7zYAFt1PmLCnZ4DqbQdEMmPSc0K7vaFAI2IFa9EBo1g5YF3ObQCAQ4hZRFHHjjTfC4fAvkvb19eHWW2+VhflYuXKlqXwNC5EdHR0QRRGiKKKzsxMpKf49GDzP4+OPP0ZhYWQDTRNih+EVeCs3skmyCoxBSdtTYS8o9Uy4eM7niELNBA/wxIojqENR8bn/MMMRnx4UpZ+Cm4/ffbda34IU6SKNVDvnNVtlsgrBZAxSjUEZCWxBnP/YcgfD3VqrPD5oiCWB4b1eZGlHujLuZJSQ9rViXzeQMUjTvDYZ4DqbfWFaQhEiBWePqoY2GDa+G4B2eBqyz5RAICQLN9xwg+LYz372s7DzNTxLy8nJAUVRoCgKY8eOVZynKAr3339/2AUiJDaCs1vmDS8cRMHvvp8NcI0/rjgTBxu6wAsiwNpgyxsKimY1hV3i0l2br357Dn7z5jbsPNYePHEU+euPT8TZf1sT62IokLawpq7Q41jmpNnQ1qMeokKLE4dmG35PFEWBomlND6ZevM5buLY6yUF/HmZC45hVRE4aliP7XZTlwGUnleCDHTXq+auUhc3IC6qlNBoXi+rXArI5RRBdfXC3qpcjWghc/MVJtRppnE8zY4e7rQ60PTXkbQt3zjwOv3zzB7CDhqqOG6JGTFFC8nP7eSR8HSG5ePnllyOSr+E9kV999RW++OILiKKIt99+G19++aXv34YNG1BVVYW77747IoUkJBZWrZp7J79eD49SHrvmJNmElbalaAqKVoYdSQTy0o09r42hUPnwxRiRn44PfnUGKh++GJUPXxzh0snx3lN630tOHIzKhy9GaV7kY/oNzk4J67mDaejnTPXv46t8+GIcV+TXfDx05cSg+a+64yzZ7zvPH2uqvMEESADgWusgOLshuPt8x7z7H22M9XsAN/zfub6/F55TJjtHURSemjtZ81qKtcOWOxgUw+J/vz4DbFaBIWc/gXsLNel/boqiiQl8DBD6vW6LAq+5RUEUeDjryiH0dekKkLedG9C2GBZMWpZPSB2SkwrB7YSr/pB6PGIiRAIAfj5jRKyLYJqDD84K6/o7ZyoVJVby4BUTIpp/sjA4NQ5NpAgyDKtnzj77bABARUUFhg8fTmLuEWDPHw6+rwsQBfDdbb7jqgNyWKisEuv0Lba8oXA3H/OnHWCOJ2JheWwlcVosH9K+L5xe0Mh7CkwTCWdDAueEEGAiGurCi5FxIdyxg3akw16QjilTpoB5qy74BfB4VRUNeGvWi7kYqzEv2H5vwLPfJRHHZJGTa+L53g7QKRm++MBsTjGYgH32roYK3TxpW4psQYTNzAfF2n2LAmI6p4g/7GqsVHgFNrQ4MQCI13GCkPyQphf/GFqe3blzJ4T+Fe329nbs2rULO3fuVP1HGDhQrB1sxiDjq/wm8e3X0hjFtOZMZC8LIV4IdwIW2MTDzc9eNCp4oggjfaZoCT5sZh6Y1EzPv3TjwoHX6RBFM2AHDY1U8XRRM6llswrk+wcTMCauyLvhajoiP8a5ZAJeoGM1wdUHPewFpbDlDYWjeDRGjpsIR/FoMOk5Mq2y0a0NdIr2fklC8pOIizKE+OKZZ57ByJEjkZKSgilTpmD9+vWaaVeuXImZM2eioKAAWVlZmDZtGlatWiVL88orr/i2FUr/9fXp94uRxFBvOmnSJNTV1aGwsBCTJk3S3F9CURR4npiADDSY9BxZkHIrhDhvTDtAW5PoCSdA1qqSjjh/pXIhSD9t4KPI00d/kqKnafNiywtdWDLyRLGYm1GMTRZv0bvHWtrPqHmWplMyDMetjCZeL7I+CxBB8HlyTRSMxPEVA5wbSfdPBmIvKDXsAMqWp4yL5qwrl8fbJEIEgOChUgiESJHILW/FihW444478Mwzz2DGjBl4/vnncdFFF2HPnj0YPlwZ13fdunWYOXMmli5dipycHLz88su49NJL8e2332LyZP8Wj6ysLOzfv192rdTRabQxJERWVFSgoKDA9zeBIIWiPMHFvV72pKZEVsBkDNK4sX6ZxARcnbcGY5OfRO6grSKUaaJ0bhlOXERj5qzyRFbM5wLNvQOJtCZfHmcztki9vbJa/UwMYNKywfcYd3QlOLvBsDk+odheVBbXmhRRFMD1e9TWTydv8HoecwMFSL1vRctcW+b5N47rj0AgxDePP/445s+fjwULFgAAli1bhlWrVuHZZ5/FQw89pEi/bNky2e+lS5fi/fffx4cffigTIimKQnGxMixXrDAkRJaWlqr+TSBIEXoj492TsqtPavWGeDo109QkjEAIhaCaSL2JbAj5hyND2nIHA/AIiV7tmlQTRzEs7AUjwrhDaPs8Ywkl9eoapTAmRqAd6Zr9F5utDFdEsTbZXnShrwtManyaY4q8ck+iHnxPu0eo1tFCmvUGriVgi7xbkiYy2zQSjYG62BhH3dSAJR6V4J2dnejo8IcUcjgcstiLAOByubBlyxbcddddsuOzZs3Cxo0bDd1HEAR0dnZi0CD54mZXVxdKS0vB8zwmTZqEBx98UCZkRhvTveSrr76Kjz76yPf7D3/4A3JycjB9+nQcOXJE50pC0mPRBx/oSCK0wVyi7SDhPVSJVzOlSDiP0SIUbY2Za6x+FrPvjLb5BzfaofR2K32WYGEyrMKMOXCkoSga9qKyuNPcCS51Zzr2wpFgUpXeqgMR3fERGkQUeHDt9TINotmQHFxHIwRnt67mks1RrswHe50TJhAPmUYQ4nScIBBiwfjx45Gdne37p6ZVbGpqAs/zKCoqkh0vKipCXZ0xZ3CPPfYYuru7cc011/iOjRs3Dq+88go++OADLF++HCkpKZgxYwYOHjwY3kOFgenZ+dKlS5Ga6plsbNq0Cf/4xz/wyCOPID8/H3feeaflBSQkDrRkchOKKakoiuA6Gg3HZtObJEgdKbBZypV7AsEKzModMs+uRjyZBvw2O51jBw2FLW+YpkMdqVCqtvc4IvPH+JHVAMDnnCCu0HImFqBx8y4SeN6j/xq+py1SJTOFq6ECfG+nzExUzyRVC3eA92AvbEYebHnDQloAcTgcsOeXwl5ArKv0IDIkIVY09MVZvwxgz549aG9v9/1bvHixZlrldhRjXrSXL1+OJUuWYMWKFSgs9M9fTz/9dPzsZz/DSSedhDPPPBP//e9/MXbsWPz9738P/YHCxLQQefToUYwe7TGFeu+993D11Vfj5ptvxkMPPaTreYiQeKTYzDUPWVy1EEYevqtZYcKl501Sbz+adM8LZXNopgOAyyeVGCwhUJCpn1c8YHQ+fMXkIcETSWDpyHbo3nJPL8uP6H2knDW2wPf36aO098TNPVXpiAMACjL028P0UR4HLqMLPU5bzjnOf78v9zUELV9eujz/NLu62Z7WcYqiQNschrT5VgRX/2Kv55mG5mpP6qXf7YH64M5V1JgwJLg2zggnlFiTj9UYFoq871Xg487u0Ex78sYlNYM9fziYjFyZtt0sFGsz7IxnoNLrSkxnicfnhOYTwduXRupzMhrHmRCfZGZmIisry/cv0JQVAPLz88EwjELr2NDQoNBOBrJixQrMnz8f//3vf3H++efrpqVpGqecckpiaSIzMjLQ3OwxK/nss898D5mSkoLe3l5rS0ewjJLsFEwt9bu2/+BXM4Je8/mis03dQ2o2KobgXEcaa9KXp8bkN8VG6wtLMu8n6gmvOnkILj2pBMvmTDJUvkeuPhEf/uoMQ2n1GDYoFbMnFmPd7/1B17NSWPwyIPD6tH4BxMtFE4oxtTQXz1x3siLP35w3xvD97zx/LJbNmYQ/Gwh4/P1ifxl/f8FxsnN/nD1O9ZrrTlN6HlNjUMBg+vX//Qj/uHYy5p5q7HorkAbSfvnGU3H+8f5Vv1+eU4YHLz8Bd54/Fn+65AS8Pv9UvHeb/LsJfAYpE3MFXDyxGE/+dBJeumGq537T/ferbuvF+j+cq3G1h+w0G1bcfLrvd6rNLyyeOcYvbD9y9Ym4cvIQPHj5CbjghCKsvvMsPPaTk/Dv+afJ0nnJS7fj4hMH4/ppfi2MyHO49eyAAO0UYGPUv58Th2Yrjh1r9ZhhPjVXe4+GdDGiuUvd7PKL356tuoh13WnD8dNThuGNX3jq5PX5p2reJxgj89Px7/mnhXx9JKFUTI9taiFG+hfrRN4NvrdDdurRn5wU8YUfPQSXsfkAm10EW95w2HJLwKRm4eH5sw1dF2osUwCYd7q+9lHNU+9A4aPfnAFG0m7sbHh7Q+88f2y4RQqJuWUC7r/0eNPXffnbc6wvDIDPF52Ff14/1dd3GUW68OhlzlT1Rc13fjldtV+ONut+fy6e/OkkQ2mzUpJvu5HdbseUKVOwevVq2fHVq1dj+vTpmtctX74cN954I9544w1cfPHFQe8jiiK2b9+OwYMHh13mUDHdO8ycORMLFizAggULcODAAd+D7t69GyNGjLC6fASL+OPFx+MaScczODv4SneKzaSzAsmgHmwVevigNCyaqT+4BNvLqCtD0gzYnGLYcopVBVGaAh6/ZhL+PneyYVO2a6YOQ1Zq+B3ekJxUPHPdFAzP82tub5wxEjfNGClL9/sL5ULbsz+bgrd/OR2zJyo7jOlleYpjWmSlsrhi8hCk2YM/S06af5U+K9X/93njClGap5zoAh7BysjAUCp5fgAoyUnFJSeWyCYwkUZ6r1Q7gxdvOMX3OzvVhnnTRuD288cg1c7gzDEFmDQsx3DemXZP/pdPGuKrK+n9RFHEsEFpWpf7OE2ymCBdHZ84RD5ZeGLOJMybNgLPz5uKMUWZ+PGUoThjTD5en3+aYmLxxW/PxtPXnizrEwDgrovkCwOiCIwtUnfQcsEJyn1o3vKlsOp9R166Xbamo7XaX1aQgX0PXiTTFAPAX66ciId/fCKyUjxt8cwxBYYWxNS47KQS5MapViCwT2KzC0GrOhjz1CDf3SZzPHPdqcNx9ZShKF86G5UPB5+MRAJRJaaj1HGNFyY1ExTDgnakgc0uxA1njgGbpZw4Swl3/252qr72MVr7g+ORE0qycWipMUHeCLecHZvYtNl24FoNCxI9irM931m4o5B0kfb/LhyH0YWZmDm+CMcV6zu8Kspy4Mcn+xeMXvm5cqHsx1OUC0qTh+dgSmkulpsUUkNFr19JtTO4fJIxS6f8TEfM98ZHgkWLFuHFF1/Ev/71L+zduxd33nknqqqqcOuttwIAFi9ejOuvv96Xfvny5bj++uvx2GOP4fTTT0ddXR3q6urQ3u63zrv//vuxatUqHD58GNu3b8f8+fOxfft2X56xwLQQ+fTTT2PatGlobGzEO++8g7w8zwRny5YtmDt3ruUFJFiI2f1bkSkFAIAXRJnFq9rkwpavrZESxeB7ypiUDMtXlMMJ6eBFzdKXgnVORiL13ow6RDF6/2QYN/TaYDw/nxXtWA1v29azTpTeO5jVuyEPtnFd06FjyxsGJjUL9oIRms50wtHGhUuwfe9qHlP53k5DeTNp2bqLiGyu8S0IagR+toH7ImkDzosGCuHuiUxGAcEIkXzueHWKFypJ9jgAgDlz5mDZsmV44IEHMGnSJKxbtw4ff/yxL8JFbW0tqqqqfOmff/55cByH2267DYMHD/b9u/32231p2tracPPNN+P444/HrFmzUF1djXXr1uHUU0O3yAkX02qVnJwc/OMf/1Acv//++y0pECEyBE60It2xC72dul4EBVGUlUEIWLVmM/N093GJiM0kPVL1RlHK5zFzq5jUheYJKt62Z2kSbr1Fu95lCy/hZNRf8OOPPx7ABgAAk5YTTo4A/N5odfcrSz5rK7zXJusklbY5QKuE85Cj/vCRrhO+qxVcVzPYnGIwGgt1gaGZXPWHFWn0FvnYnGLVeKbe8DThoOhrGRtsuSVwt9aATsmIP0dLhIQjnMWtYP2i2lnv2CBtujQFCDEYjGNoRR9XLFy4EAsXLlQ998orr8h+r1mzJmh+TzzxBJ544gkLSmYdIdnmtbW14aWXXsLevXtBURSOP/54zJ8/H9nZsbfFJmhj9rsOayANskrtdRvubq0FBE628kvRTNCV4PBXR+O/lzNTRlNhJ0KsOzMxC+O/dgkAkJaWBiY9F6KzB0ymtmMhoxhpW9K2EcsV6ERZ6NAjcB9kNBCcPeC6PH4RuLY6MFpCXcDLFUUBNOuAyPn3weqZrdI2pfmuFQKk5v0caRHNP1FJgKEyIlj53KYXy4IkN9pvUhQVk042EeZXBGswbc66efNmlJWV4YknnkBLSwuamprwxBNPoKysDFu3bo1EGQkWEdUPO0i/xffLmIKzG4LbKdtDaS8caSh4dDiPE+qlkazCwPeT7N1wPAw04ZbBrFlvJO+ne53OOTYzD7b8YabjsaqVRVBZDVdeZ2ZxxFSRCP1Est4CQzCF6tWXdqQH7eelQiaTZqGJKWlYhklGU0MjWGnGayavUDWY3ltIr08IjeAAbV/JgmlN5J133onLLrsM//znP8Gynss5jsOCBQtwxx13YN26dZYXkmANlMbfRtKbvpdd3e0639sJ0dUDIW0oBImdBd/V4rnOoLv1cM3gQp+MW7AnMgL5GnBGGzbJuvdMC0NatSjvibRqQmdFG1FrD0b26tCyyRWZQUSCSC3QqMUS5VprILidYNJzwWYGcfDFMADX/7cB4ZNOzQLVPzYwmfrOdgjxyUD9xCM5Whqd/3j66BhoIqN+R0KsMC1Ebt68WSZAAgDLsvjDH/6AqVOnWlo4QuJBUZTuxJBrrwcA9LXUQhSUjnPUHOyoYcSxjh6hCkRR3RNp4l7R77T17xgPWkaChDC03FqvUu8V600cZY51TJSDYBwrvj93SzVEgYdd4uDM3aLcoyi4PeapfHerTIhU68sFZ4/kuuBhoCiK8jlYI30KIVExs1hGUQb6RZ1NkbLPhHwyhAhj2pw1KytL5lHIy9GjR5GZqe+6mBA/GBmQQxmzvZ0l36O/V4dx96CvO/T9PB4hMuTLQ+5caQsmMk0qsfFSVcKphCro1neox97z5RuqFtbgdc1dTtiY4F3LliOtQdNEGr1HSghToH6CzVFCjRfI0BQYDVerDpX4cd4wMHor5TKHWkEKzhoIQh9qe06k92sWKkzpXOQ5CK5eiJxLJuyJQvAA7oKz27NvsqNRv4wGrU4omjG0vSEQvb46iV+95dDJ/KHoEO4Cl3QMDJxv6VWpp8/Vr3Nepd/ccaxdWYYYvTuy3jNwMC1EzpkzB/Pnz8eKFStw9OhRHDt2DG+++SYWLFhAQnzEEfPPGCn7TVHKD/vPV0xAcZZa7DHvNeo9wcnDc3DpSeG5WL/ghGI011WHlUcs0OobLz7ReLDXdEl8xlvOHoXhg9JwzdRhivdDUcC/55+GwkwH/nWjvpbfaKddkOnATzQCFWtx/bRSjC7MwCUn+t954P0mD8/x/f2fb6vw3m3aAXXNcMUkc+1s4Tllst/DBqVinCQu1wvzpgTN45azRmFEXhrmnqYdYsYIfUGs9UYXGg8/c9lJJThxaDZOltSzGR6+aqLvWz/nuAJkOIwZobw+/zT87eoTVQOOXzlZGQfstnM9jkn+v703j2+qyv//Xzdr072lewulQIG2bJa17CBrGcRxAVQQ/CiKiriMOuIyII4D/pT5uHwHR8cF9eOo44ijo3UUFQcYQZApUkEFtGylBQFLC6VtlvP7IyS5SW5y701ukpvk/Xw8eNCce+5Z3ufc9znvs1r9HAkop4Px0K/KkJNiXxrvqy6U5cnbK3fL+J7olpmIhSO7y3pPjfgyxMb0znKb/Vg5q0JewLx3mcUMxmywdZwTfc3c3ATzL41e+yYdzB/h+qb4VzgNK8lE/8I0Zxk77itN0GuQlSy8NQIAkgzCxuWqy/pjlh/d4aiD/+/qi5xusXjpuVz+7/rhzr9vHNsDJVlJWFbd188b4si9bzpYfN3lu+meCbLCCXSp/ZDiDEwqy8X0/q57dOeNcL9CRkh3Olh7TSV+M6U3CtNN+O00Ydmf75S2D3nN7EGS/PF5hHe/pQMp/Zsp5bnOvz3vYe2RlYSiDOG7Vxlc/Zwn5wzyuj+aUDeyteYTTzwBjuNw7bXXwmKxb27Q6/W4+eabsXr1asUTSATGQ78qx4tb6t3cPDtv80YUY96IYnS/70PBMHx19npkJyNBLzz+kGzQ4s2bqvDlgZN4fGuzzyPcUxJ0aG23eLnrRI+0t8PAJI8mH1w9wyuPSh6s47h098PdwnL0x7LpZVg2vQwAcKbNe/nX6NIsbH9gkt8wustQujtEwhJi5SzvRsWTtddUomrV5wAAg1aDooxEQbnLZUpFHv6xS7hDKsS90/pi7Rc/On9vvnciPtnThBtf2+kMj49QeS6rLsOy6rLAEiwSNh9/nWNPnr7qIi83OX2c0twUbLv/YukvAPjbTVUYVmI/sXXf76d7lWV6ogFvL67ClX/e6nTr6qOjwIc/wy42217cJUm0/ms0nPMb9FXfHplVgYfe2wPAXkfu9dE5A4B3bq7C5c/a8/S/Iyz41YxqlD70id80RAr7NRhHvNwT9FowxpwDgddWdcfJ1g48/fkBAMDoXlnYcuCkz3DdlpoyG6wtJyWdBGtrPyvo/sFto51/zxlqNx5r2zLw+w+/A2Cva3wWj+uJxePcB4Q8y9ZR5qNWf46G5vNuz+YM6SppBu1XAwrcBseC1VfRzujSLOff91eX4X4BPTitIg//2tMkK9wZA/Lx4e7GoNMnhafmDnL77agnQvzrjjGY9uRmReP/+82uAVRfcScadILt48KR3TGgKB0A8J/7JvqMQ6rq75Yp3yC7amhXzPcwegHx/s0lgwrwyV77diXPCYguyQa8vXikM7/DSjKxvf608zm/n3PpRYVx/x1GE7KNSIPBgKeeegqrVq3Cjz/+CMYYevXqhcREGj2IJoI5WEeqAWZubnI7Mp1/ip/nPZEAoE3O9Hu3JJ+g90QGvKRTres0Ipsu/vIboaU2gaJEUJEqM7FYVVuVZOCZBSnLvfl9e7HlrIR/NHrhgQihUpAjaWZ2XxIf7FUiBoMBnZ3eh/JEing7JIyIH4I9ZC/Q9pJUeXwieTlrW1sbbr31VhQWFiInJwc33HAD8vPzMWDAADIgCSf+9EjnCdfMqA3eSkeXHPw9dVJRZSdCYDmr5FfDnB1/xoO/pYxyUeIyerWiVbkVKSV5Qkuwxd+JQL5VLmul4LT2cWH79XCe9zTKCYg3W6wzBJ2u/v37Bx2GHOKkuCMCyTZ0SJVtLBlsdEJ3dCPZiFy+fDnWrVuHGTNmYO7cudiwYQNuvvnmUKaNCCHBdPYU+eQFZiLlEuttmVRDNxIqOFxxKjIT6fdZeGuR28F5Kq/A0pLneWCEhAO7eH+rvfug8iLygn+vopcRKUPanI8ZzmAoLHTtA+vevbvi4RPhISC9pdIPXW32i/T2yM+e8whpLVn1QmVyJwJH8nLW9evX48UXX8TcuXMBAPPmzcOoUaNgtVqh1YZ34zQhHw7ylUtAqkiicuBPVnEaDTQSl7E6ownydFY1duADmdVx+lU2KZLgN8Chij+W2xolTvpVK746Z54HfKmtExftOE5P5cDh7NmzSE9Pdz2TIWtbm+ukR+bjPketKQXW862Sw8zLy0NeHn9PsvdpkkohNtsdw58eEcUoXS8DWs4aYFyky+MTyTORR44cwZgxY5y/hw0bBp1Oh2PHpB96EWq6d+8OjuPc/t13332RTpZqUEpBBTQQ6aFhuvXuh4Ke5TDm9YIhpwd0KVk+3vQRHliAKbETyT5ELHRgPLOg3r2i/uWt4mRHBZ7yEzvMJNi9zOEgmjtDGqMyW0s0xiTn39azpwX9aJMzFYuPICKB2lSR1OT42zGitjyJEcXqloCMmUir1QqDwX1vhE6nc57QqhZWrlyJRYsWOX8nJ0s/Rj+ekDIr6bfz7eN9zuB9ZYil9ZTXxdNWxqCVcJdgoOmLRrwNM2nvRapj7raBP0RxRPN+CbEiiYWZSK86KzuE8JSvkqcxqxnnfYpCeyLlhKNzHdHPLMIH4nBaPbSmVNg62vyGpU/P8/s8EkRZsaoKVZ4nECNE255I+95r199S4S+tp9oU3Ug2IhljWLhwIYxG116J9vZ2LF68GElJrlHL9evXK5tCmaSkpHgsmSECxaehKOOrt7afhfWc96XyjAWnCINVomqcDfFMk5zGOty5MVttqmnIxFBhUQNQ/2X3geyblmsYh6sOqbUOKIE2ORPWs6edh+oAdn2g17vf1aakrHUpXQAAmoRk6Lt0FbxmxJkWBQ7mUZpYrg8hJwDZxfIBaUpitUnz50+ewVZtOd+GhuOcp7HL0S8dFldGqWZEN5KNyAULFni5zZs3T9HEKMFjjz2GRx55BF27dsWVV16Je+65x2sGlU9HRwc6OlzHmbe22vd4WCwWmM3e9/ZFC55pz0sxYHeDaw+K2WKGWPZ85b93ThISfVzynKDjYLFYkJ1s78D4ujesJNOEt/971H8C/JCWoMG40iz8/b8NTreuGSYc+cX9vrDUBJ1gPsb06iK7fIX856YYZYfDGBN8h1nd9x5ZJdZBxhg6JPir7JYuKbwBhanY3dCCXqnC6QSAjT/8jCHF6c7fWrgahbxU6TIR81eQ6v3tdss04fDp8wK+vcMzm83ISdL7fB7K77zNIpAei+t3Ubq4nPw9t/H2qlmtVkXywQ8jw6R1+907Jxn7Tti/5+p+uTCbzbB6rESxWe3yTDUKrzJgYB5xCH+fgZKdbMDPZ71nzrqlu1ZIiMXnubpG7e2ANikDGp0BnMF1R6fVas8DP+2Zia7m/qKuqX7viRTrEfKXu/q6ZoSPkAxbz3f6fS41zJE9M/H2zgbBZ77o0SVR0M+40iz8e78fucQ4kspB5unbZrMZNgVP7BYjQevKh2d+0kw6nDnv+r4tZu+VdI53LBbhvcBiBKMvXvpPPZZNKxX11zVd+Jszm82w8CxRs0D+xDCbzZIG2c1mMyb0zsKn3/+MHllJsPL6L54y8OzznG13/X1xn2y/MlOL/lXbqku1INmIfPnll0OZDkW4/fbbUVlZiYyMDGzfvh3Lli1DfX09XnjhBZ/vrFq1Cg8//LCX+2effYasLHn79JRH9jWeTmpqatzeP/zNFhz4mQNgN/42bNgAV59COJ6PP/5Y8BnXuAcmo/B73VMYtmzZAgBI0GrRLmBEahNT0Vn/NfYc0iKQcbMFpVZ88+VGDNMBtSla/NhqD+PywlYcTOXQN51h92kOnVYOo/LavWQBAOMSG1BT4+p4TC/i8NFR3wdE/bq79UI4cIbVNYnh+tJzXu5iNDef4b3jwt7OusLYtHkT9vvYcrS8Enj4v3a/bW1t+Gb7l6LxD0k8JRivJ7PzgR46DkOzGTZs2ODx1BXHV7t/gGNb9cZPXXWlyHBekkwKE5mk9FzVk8OHhzUoS2fINTFUZrXiLZsG3zW7GyrLBlq8ytoR/rxeHNIN3t/Fxo0b0cV7BbZMhPOYnQAv+Z0zu/wf27sDNQeAhy4CntmjxfV9rNBwwPuHNEjSASNz/cvnx0MaOORfW1sL7kigHTV3ed1SxuGcBajb+gXqeL4uzwdeatVCrwEmJtm/n0Nn3d/fvPEzJFz4OTpXg50nOZy3ur7xzs5OtzI4ffQAamr2B5hub27p7fou+Jz+fhvm9uCQJ1jn3P1v3brVzc1ehoHr4lDDcRy4hGTebw22b9uGU8cb3WYjG0+59H/3tn3om6bB92c0WD3Ugvt2uOevMJHhYLP97xHZNmz72XNQwF6mY/Ns2NTkembSMrfydvgVqseHG13pkaIH7ugHHGvjYLUBvdNc5ThEC5iLOWg54J2DnuHZ83VVTyvOW4CsBKDFDHTWf42ag95xzMwE/h3Gss4yMkwqtCHDCDz7nXIHFI7KteE/x6VtF7l/kAVr92pxU1+rn3JwyeRY4zHwj9Pom2bDRVl23fzkt3Z/E/JtOHiWQ2UXG2pqatDUqIGMIzgCpjTVhm3//tT521P/3lEG7DzJ4YPDdllv3rwZnt+2Qwa7eP0lALisuxXrD4qXkZS67GDZQGDVN8Lx80nSaXHOYv+uruttxcHaLVjYm0OCFvjzhXrTLcn+TfD7Ef/Z4p0/8fR/JDgbec8A4KcW+4Oeqfa4Lk4Bkos5VGadQW1tLby/5wt6/vQvbnrf1n4Ol3W3YedJDQbYfkRNzY9ucS2tAF7br8Wd/a0CfZDIcPJk/A4u+UO9LeMFVqxYIWjk8dmxYweGDBmCO++80+k2YMAAZGRk4IorrsBjjz2GLl26CL67bNky3HXXXc7fDQ0NKC8vx8UXX+x2JHkkuHPbJ3IH/ZxUV1fj9q2fALDPLFVXjwDqmvDagd0AgCmTJyPVZO9gOPzxyUo2YNq0i3HP9s+8nk2YMB5dMxJx5zbv9/r2r8To7vaRo9MpjXjpy0PeieM0mDGjGk8f2IIT7d77afRaDmar74w/eO1059+/qrahfIW90Zg6YSx65dg7U2azGRs2bMDkyZOh1+vd8ji9IheXXzLQLUzzrmP46Oi3PuOcOW4oxvSyDyo4wlo6rT8uHVTg9CMkRyHS09Ps5eEBYwx3bnMpzLFjx6I0x/ee3of/a48vMTER48dX4tFd//Eb78TRIzC4OENSGi/zkJ8Dfh6Li4uBJvsyNn59KygoRHV1fy//ngzuVeD0549qACs93K658H/pQ/bwfz+rHHOGFHnFWV1d7QxDKA8TJ05AYboJweAIb0p5Dj7Ze8LpnqxnXvL7pa0T93/9BQBg0sUXIzvFPqJ87WWu8G6UGO+eT/bhs2MHAQCDBg1C9YD8oNIP2OVV7cfv/3j8rms4gz/WfeX8PWXqFCQb7c1KNYD//HgKC9ftdD43Goyorh7vjLNfv/6oHloUULp94fgu+PjLl2cdraqqwlN7djh/T548Gdi6UckkhpwRVVUYPGiA2/YTzZ7jeHnfNwCAS35VjUt+5fJ/3w4PGfQtwsFjx+3PrhiJS5/dJhjPpGEV2PT+d87fCamZOP+L9/YFx3fI5+eth/DuwR98PpfDZQA+/e4E3jm4yy08R9mOGlqJqRW5ouFYbQx3fxW+TqspMRGPXDcGZzssePb3nysW7rol05y6UYzrLq/GdZf798P/RgryC1B7qsn5Oys7GysXDAYAPPmt3V/vXj3x/BTXjNpHLd8Ap49LTX7A1NwzDYB3+8/nCrMVH6y092vGjBmDx3ZvdXvuqDvmbxrx2gHXMNp1M0Zj/Z/c/Qohty6v+sa9nITef/y7TTjX3A4AuH++vf/j8PXnC+Xcu2sOqqsvgtXm6keMGTMGq78RTzOfGTPkpf+KC/9/WNeEV/bvdsuDo95kZmagunqY83d6Rjoeu36433AX+ynDSNDQ0CDuKQ5RvRG5ZMkS57UivvB159SIEfaO+oEDB3wakUaj0a2hbWlpAWA/NEgNFTdQ+GnnOA56vR5anWsUTW/Qi+bP13O9zve7Or0epaXdUV9fD42Pg3O0yV3s7/tYMmHfC+jbiHTLm8bGc/cuM73eO60ajcbLjS8bwTiF6gPnHY4UHOXhiedBGAaB/AgHCBgk+AukTgvJzxmtRuPmz+UunD9PtNrA5CccllYwLLHwlfzOhZYAecpPp2M+n8lFo3HVWaXyIbt+6Nz9G/R66PU63nP3Jobj3OPwVW5KIycOrUeao7EdcNQHT1k7EMsTf2+rTifUTbDXY51W5+WqTUqH9Vyzm7tQfDoZ6ZGCv/xJ/T40YVx2CbjaAoNN2U2acuQpV/ae7bpQe6bx0O3hOoNASvtv5c2I6vTeddvh3/PgP+HvQDwNchHsG/BWbPlrj/V6PbS8OqzTyU9LoOn39/151hGNjz6Qr/SoQQdLLf94Q/VSycrKCnhZqX16HcjPD2yEPtJw/KOvlAhP7j2RAep9sTXsoWpQwn3Qi9LxectFzsE6wZ22GwjBH26kTDoA9ZxWJwZ/oCDY/PMPV4hU9sXuNvX8HS3lFAuE8mRjZrWA0xkED/jQmtLcjEjGAttbJhd/7YrUb43O2xEnmq53UpJozCYdaESEGtUbkVLZunUrtm3bhgkTJiAtLQ07duzAnXfeiUsuuQTdunWLdPICQmmdJesI5oB1D8PRoxIPzFFAvwXUgAVyupxAWm0q6hFLE0N4WkGpYlHDUfFKdoCk5JvvJfK5Vx7PMhUr42jsmMUS58+fR319PWztZ6Hh7au0Mf/HRHpe5aRNzoStrRn6lC7ghG8EiShUzYhgUVFz7xfSqUQ4iRkj0mg04q233sLDDz+Mjo4OFBcXY9GiRbj33nsjnTRVIkXPhKKTz++oRIlO9ok1xK2KvHsiQ5oUWUiVitqvuJCLZ77FBh6UNGDVIkrPLHmWsZrqqS+ipbMoF6F81dfX4/z58zA3NzmXoWqMibBZ7Sd6+Tp5leM8lvolZwLJmdDo9ECnGYbcHug8/pPdrwqv+PBFNNRPtSE0401iVAexqssI9RAzRmRlZSW2bRPe/B+tRLpBCzR+juMEGxZDdjE4rbJr2wNJotA7YgazkC4O9fYZOXmLxMX1wS6VUXQ5a4BpCbvUeMlU0ohWy3JW7+fUnQw3jNkuXAIuXivOn3ddleNYgmrraEPrafsBUcwa2LH2HKeBIafE+XekoXqoHIGIUk3GTDRWBTlL06OhrkdDGglpRF67E6Hnwgcbrs/Wl8JT2oD0ijeod+W/Heq7r+QoWmkXwweRGAF8tWtSG7xIGL6hREq2+VVGDct5g8Vr+arITGQ0ECvVsqmpye13IDqO85iJNGQXO41D0Xc1WnAa3weWhdOuUGuROsokmuqclD2R0ZSfWEZNxjsRm5ARqWKUHq3p5F1CKxb2qXOdQTe8HebADlTgp1OMcDVWQoZRoHsilU7y0V/OexlkSQbvzpvS8frK/c+tHZLe33WkWbG0tJul15lQsWn/z6J+3DryChaI1Rb5/APiRqUnajQyY6Xjdfr06eAD8ZhF5LR6/4ahSmUn+WAdsn5EiVcZqT3bLef9H2hIEKGAjMg4YsNe6fc0pZnEZw3nDu3q5VZRkOb8+z8HTvl9f1q/PMnp8UffvBTkpyWgJCsp4DDkzApNq8hDgl6DWYOk3SOalew+mn/sTLvENEmn3cNg/8Nl/aHz6KGX5afKCFGcvnkpgu4GnbBaWVBV7Pb7+6ZWxdIS6EmUSnYMOi3ihpyFd/+pVkELyuLnXtVQcvj0Obff3vJ0d1gzexAAYGLfHKQn6jGpTPzuvlAzXSE9BABVPbogNUGHfoXKfmvhZGQP9+uw+ve33+WqSxE/JT031aXrxpYKX6vlQPGD4wTchpdkIs2kR1VP/2mJRUb1Ck2eb53Q0+03X/deVlkIrYbDvBHuuv7Oyb29wrlysLL3w0qF39b7azYyEt338kZygOTV64eJ+jHqXYM75fmpyE01ojTX9z3T4WDpxF4AgAdmlNt/X2y/O/TBGWURSxOhLDGzJ5IQh8mcBBEbcRzfJxtv7jji5sY3IDqt/mci+Ybq/84ZiDvf+kZCqrzTWLN0DGyMQefjXkopyFnq9ey8SpitzKexxGfrsomoqWvCIx/sdbp1zZB2ub0cA8fTCJ41qBBTK/Jw7Uvbsb3ePiORoPd/F6ZcdBp58n54Vj+8svWQomlQGwOK0rD76BlJfoO2IfnfcxDW8ODiDOw85H1BvBQ864D3Ujf33+N6ZwMAXlwwBJ1WG4wi97MqQaLArDyftddUomRZjfN3oAMSj8yqwLwRxbDYGK554auAwvDHbRN74dS5Tvz1q8OifoWy4C9b/1wyCh0WK7ScBjoth2f//aPzmcFggDGvl6Q0ajgOBx6dDouNYf3Ow9i03/9AYqh588YRsNgY9EG0DUqj1XCwXljXLrWqLRzZHeu+PCgrnv+7fjg6rTbYbPY49VoOi/9vJz7eI30w2ZPBxRnolSM8eAgAf5w9CKsvG+DVNvbJS8G+309H7wc/cro9fuVAPPrr/m5u4YCvk/zJX65OfeTSfpg3PDQ3AfTKScHelVNh8tOG81P7wW2jnX2iJ64ciLvf9t23en7+YNz42k4FU+viril9sGRiqbM+3DW5N5ZM6CWp70REB2REqhilRmo5rz9CG79Go4HNZm+89JmFsLadgTYxze87wewP02g4aOTcqRhAh9vtagaOg0EnLQyhzovU+OXIRCjIBL02pBuPfBneal3SJoTS+xLFQpPagYkWPMcRPOu2L3lwHBcWA1IKip6Sy9k766HAZNAC58T92XEYKcwrf3wj2Wg0oqOjAxzHIUHg4nXWed7LzR8cx0Gn1UCnVUf9DmV5BIpe6zIipSI2ECKE0DcWrDEtJEvPcvZlIAi5R8KY4OdAyXsUkwzakC71TTT4767zo+b3icQGK0M9wOJZxmRAxhZUmipGaX0kJzhpo/ECG+oBZGRk2MMAoDGYoE/Pg8YgbfYtHES6SxGKfWCaCGwu83mwTtRf3hI61NCxVhIxo1ENhyfFmszlYLG4TldlAKxtZ2A+8RPOnj0LQNyAZrbA9rVHAhVUNdk46ma0HLIllE45+l4NZcSv8/GgG9QgcyJ2ISNSxYTy2xdTLEyCH19oLkxPxJSCDjAvgVwn4vQnQ/5qOqAkpso9CMIphkCXYAaLp5HoWWfV0IGhQQ0XlpafwRjDDz/8AABobxfen61EdVJD2auRQAxGNctSTl1Rw6BSqNrKSLd7AWcr8kVCRDFkRMYRcpdaiPkXesxxHHJycgAAmoTAD7qJJbw6+CFQ2r46JtSB9o/ifRqFr2UJB8Ekw7ND5j0zGflMRrpzpxRy8uGc4eKVB78kdDr70jiDwf3wkKSk4HQ2X9fFitwJ/0TbYGegM5Fq0dcEoSbIiIwjOLe/JUxFygiPT0JCAgYNGoSEzAKpSVM9AV9mL9DySG1IlWicQ9mR8xV0PHceI9XPiNSx+2IzC2roeIWrOqqp2jvS0tbW5uUGuJa58o2+nJwc9OnTBwMGDAhDCuOXSH4TodAT8gwxFSgEHnLadbF8qixrTtQwkEfELmREqhilFa6c4ILtEGm1WtEldvGq2qQvZw3tYUFB46N8o2n2M1bqYDDLWYOpOmLvqqJjJVM0aq69UsXpqA779+/36aezs9NZb3r06IGuXbvaD6LR65HdrRe0iWmST2UlQotaDAGh71neclbl0qIEsTTgqTYDnYgPyIhUMZFUCVI6pWJKS+YBdKom0MZGcE9kKA7W8TUTqXxUomHHUsMcDPEgBrGZSDXsgYqmQQ0xpOZEyJ+nTjebzc4ZSZPJ/eAzjc4AXWp2ACn0nwZCmKgYjPGBnO9LDfqAD9VRgggOMiLVjEL61qG3OQE3T1IT7HtlKoszRMPNSTH6fV7cJVHQfUCR/bqPogzXcykXtSuFWDtWlu99UXi7ObD06QSORBcKXwg5o7a+7oAslxiXXDQcUJCmnhN3iyTevemFwn0asUvm+Uf1B9uhautU5uTMYOpIlySD3+f8u2AHFvm/5idUmK3h6SrKvYc3EM5LLHOdgPLo7HA/RKepqcn5t+eA4Ntfu9//6wtPHSBnNqQwQ7h9CJSclARFwwsVbZ1WZxs0QOI3odS3XpoT3OXzffO8dUVJlvR9tErlwxdyV2Tw9RMAZCTqffgEbCJh56VGtv6d67AIundaw9O3KkiPju+PUBYyImOARWNKJPmT0sC/t2Q0bhrXA/87ZxAA4Km5g9A3T/hy4YFd0/FAdRn+PG+wKw7e89lDujr/Ht/HNar9/PwhAIDp/fJw1+TeePV/hnkZdm/eOEIwTjkNFp9/Lhkt2e9LC4dgWPdMNzdjgHcbpSS4N0q3jO+Juyb3lvSuv4uFPeEbJ90yXZ2z307vi1vG98SHS6Xn3x/LZ5YDAGofmoKLy3Jw95TeWHfdUDc//praSWU5iqTDwav/Mwy/mdwbUyvynG6OuvPOzSMF33l7cZWiaXAwoU82fjutr18/XZKNWHVZf6y5cqBPw18qKQnKXPN7zzR7HfngNvl1pLvI91iQbsJN43ogPy0Bz1347sONXFtdiZn0QIKYN0L8onKp9wXy69aZM2cAAMcb3A3D5uZm59+ebYNF4jKS8X2ycc/UPpL8ejLpgv545X+GBfS+J/2L0vDgDPf2SK1suHMsFo/riT/8ur8k/22dLgPhT1dXBhzvjWN7YMkE+UuUP7htNG4Z3xO/meLdds0dKl5vw4XUQYxnrroIK2aWoyQrya1vwK+LngapzvNS3Au8tHAI7p3WB1U9uwSQYuXw9cXKaWeevuqigOOv7JaB+6b3xV+ujYyeJyKDMr0QIqwML8nE3mMtaL0w8iTWkZNDSVYSlk0vc/6eNagQswYV4lyHBRXLP/byv2hsD59h8WfhhhRn4IsffgYA5KXZR6w0Gg5LLy4F4D3yPaKHsEIeLGGGVIj+IiO+/D0n+Wkm/HZ6H1z+7FbX8yCmFvht0b0iRkag8BvPSwe5DjRKNuoUjfO6USW4bpRr0GLJxFJvT376nxeX5eLT704olp6xvbMxtrf7srsRPbrg4OoZPt8pzlR2BsRBQbrJa9BAiKuGKdPpSjK61Hcwdk8wdUTKZ7FsepmbTiGESZVQdwLh+PHjSEtLQ0f7eZ9+At1Ty3Ecbp3QC49//INXOOIHkXDC+iMIbhjjuz1SC2kmPXrlpOC+6YF9c92zAtdfCXot7p7aB+9904Ajp33XB0/6FaahX6FwG6pV20ZHCcwc6Goj+TNojr6JEL6W7U7sm4uJfXOVS1yApPoYVJRTOpcMDPwwRI7jsHhcz4DfJ6ITmolUMZIPYJHsjwCE5SC2ryOa9vmpOamqqIMc/0/lUqRmuYeKWDzMQYksBRJEqOqP4zoPf5jN5hDFTngSbP1SW1uktvTIhZ98Lf/6j/AnJUiEK1YMqmhCRZARqWJ8ffwBKzcVKxO1d0aDaVBi6WAPKfjLr9oOVogVIiXVaJiEkNvJjdRy1lB1xs+dO3chAt9+PA/WUQL61JWEhBkqbLyl29E4q+qAvjciEpARqWJ86gQFOhuhUjjRqsjEZqSCuUIh3vArKpXVDyXraySrSKSiVvvgTzQhZbApEHF3dnYGkJrgIZUZGtT2yUX7IKmVV1H96TO1XLNCEGqCjMgYQPR4cOf/kVOCaupsCqVFdDlrqBITg5CsiHgnIG0Xwg/HavV/KqbGx6EhhPIEUjdU1Hx6Ee2DBfwzpNxmIqMsX1E8iUpEMdRyxBFBHQ4ThjjUTDQ1lJFOq79ZWzUsZw3dYIp7viNdDkRgRGpmRSzWYFZDHD161OeziooKVQ3yEaFHSd0U7WrObTmr255ID32u8pz6atdoBpUIJWREqhjfeyJZ0MsCSbG4Iy6PwBuQQBvsaC2jKFrNqrr0ENFLsEveQ7lk/uTJkz6fGY3+7/sNFLV3uqMVtbUL0b7Vw8ozImlCniDkQZ+MivHVWDCGgGwacxCXzoa62Yp0syjW4QnTfb2KcPJsR6ST4BM1THiEqnPr2ZdqMasgs0TM0NIufJm4VITqfWFhIc1CqgCpW1LCFV88YeMpbn8rZdRmvHtCZUpEAjIiVYwvpTC6NAtXD5d+11xDs/0+KF8XSC+7cF/VA9XK3uU2qlcWAKAoQ7mT/+aPKFYsLD5mi3/DosPif0+RP6r75wMAyvJTAw5DDm/uOCLuKQRcXlkEAFjq5+43tTV0oexAb24Kn3od53FXZjxzz9Q+br9fkHn5df8L9+GlmcJ7jfKVQ7r6ff7GV4e9OrKPzKrAylkVbm76jAIUFhZKijM7m+pNqPG8ey/URnu3EN2Dy4efJzlDcovGlHi5OdqNYHns8v4BvVd4oX+i13LQ8TYWDu6WqUi6Qs3kcvsdldeP9pYtIN7mVna1372dlRyaFQlEbBPeVpJQhJyUBCQZtc7fYk2So1Hh++NvIL9pXE9cMbgIXfwokUDmbrKSjfhm+RSY9Fq8sOWnAEJwseOBSdBqOGQmGYIKBxCWl1Efug5/18xE7PrdZCQbY/tze+LKAbi/uq/feqT20dxgiOSqrtxU35dkxxu3jO+JOUO7wmJlaDdb0T0rSdb7KQl61K2YAo7Z8Nkn/wIAjCnNwub9vpeEAsHvDeudm4LahybjtjdqseWAd1ytHe4zkV8/OMnZ8fvde3uc7hpjIvLy8tDQ0CAYj0bn+j61Wq2gH0I5npo7CMtnlmPw7z8FEPysophR8NlvxomGEayuWjN7IN7/5pjssAYXZ+Ivm+vd3Kr75+Gd/9r37F4/ugQvbqkXetULvZaD2WqP/PPfjEOP7GTpCeFh1Gnx7cNTodNwbgZ+WqIeW5dNRNWqzwMKN1w8N28wms+bA+4bpSXqsXvFFBh1NKdEyIdqTRQidzmeo+POf8vzJC9/HX+v8Pw0Yp5GQppJD4MCyik7xaiIAQlAsBUXawiDbXTTEw3QaWP7c+M4TlY9IohQwHEcspKNyEtLkG1AOkhJ0EekU5WRZECGRD0nd+bAocK0KV2QkpKC4uLQrOog3JGiF8XaFzmTl/owtDOBGsKhWrYbqAHpINmoQ4Lee0AlOwraM40Cg+upCXoYdTSgpDRr165FSUkJEhISMHjwYGzevNmn3/Xr12Py5MnIzs5Gamoqqqqq8PHHH3v5e+edd1BeXg6j0Yjy8nK8++67ocyCKLHdqyXsODQzr6EK9z6YaJuB8mzUo/voAPWguuWsCoZFB4nELmrZNygnGV26dHH7rdVeWAmh0aB3797IyspSMGVEuFBDVXT/HqTrPaGkq/lcHrV890T08dZbb+GOO+7AAw88gNraWowZMwbTp0/H4cOHBf1v2rQJkydPRk1NDXbu3IkJEyZg5syZqK2tdfrZunUr5syZg/nz5+Obb77B/PnzMXv2bHz11VfhypYXZESqGKX0l2PWMZhOrluToWKlHyhisrHFYqYjgCoaZSpKQiZya60aqnliovveOIvFvhyW48LT7JPKlE6460uw8QU+E6mCDyPOIIlHhj/+8Y+4/vrrccMNN6CsrAxPPvkkunbtimeffVbQ/5NPPol7770XQ4cORWlpKf7whz+gtLQU//znP938TJ48GcuWLUPfvn2xbNkyXHzxxXjyySfDlCtvyIhUMVJn78SXiNg92II4YTTu+wOREABp/6iCOs2xi5S+r9rKP9qvXohVArGjlF7JE2zV4OdBTliCM5HBJYUgwkpraytaWlqc/zo6vE/D7+zsxM6dOzFlyhQ39ylTpuDLL7+UFI/NZkNraysyM10HPG3dutUrzKlTp0oOMxSQERkHKD3453dPZIwaPrRUURk89+JGBDWkgSBCjFDnxg59AJFFvvzV3K7KaRnF8kGtrPKoue5EI+Xl5UhLS3P+W7VqlZefkydPwmq1Ijc31809NzcXTU1NkuJZs2YNzp07h9mzZzvdmpqaggozFMT2cZEEAHUoEdHZ0ginMdQH6xB2VLE3NkRlSVUkdpFSayOtw8QId/2k7yF24S9LlTUTKXioXWA1Jdxtstq/byI87N271+0KJaPRz2n0HpWGMSZpSfcbb7yBFStW4L333kNOTo4iYYYKMiJVjFL1wrmclSwhAIEZMj6u2CSiHOoYEFKQ0kiHQ73Kqa5tbW0hSwehLPEyiKmKQcQAid4yiF6Zq5GUlBSkpvq/8zsrKwtardZrhvDEiRNeM4mevPXWW7j++uvx9ttvY9KkSW7P8vLyAgozlNByVhXTK1v4ePrMRAM6La4NjmKK2dH/KfERnhT4l/D6Owo6PVH4qOmCdJPf8KUeax8ukhPcx1fUuJzVcax3oYhs1YQabjnhH4GvUXB9bUmA10kQBB9f33NuqhF5adK/9XPnzrn9TjNd0GlBVnnH1SJC6aRvIDTwxzCUMMR6BnklBh85M4mpJr2XG/96CjmGWjha5Fgwv9ITvWVOhBaDwYDBgwdjw4YNbu4bNmzAyJEjfb73xhtvYOHChfjrX/+KGTNmeD2vqqryCvOTTz7xG2aooZlIFfP4Ff3xm3VfYNnlI/HrP29zuk+tyMM/dglfJC2EYxT9t1P74rl//4QRPTJF3vAmQa/FA9Vl6LBYkZ3iPX3/xJUD8V1jC8aWCh8bX90vDztGFGNYiXDc43tny06Tkng2Xn3zUv0+F2PRmBKU5qYEmSr//O2mKqz94gBum1jq5r58ZnlI4w0GrSbyVmRGkgF3Te4NDvb7sYLlpYVD8FFdE66tcr93j1PhwEMoyEkx4kSrr/13sYFQZ3LRmBKvi9PlcOXgIry986iX+20Te6G5rRPV/fNx7Uvbne7XjSrBwpHdcfj0OUwqkz/yPKQ4E7MGFmDCyAEBpxkA3rxxBJ794kcsmdjL6fbOzSPxxvbDuG9636DCjgeEJrWF3Ob0sOKtn+wDtlKNmT9dXSnJ3+NXDMD/9/EPmD8i+LtC5Wi5ym7puGlcD5R0cQ02DC7OwKIxJeiZnYx9x89Kjzd6pwbdSDHq0NphCVn4w0sycePYHuiVnYx739kdsngId+666y7Mnz8fQ4YMQVVVFZ5//nkcPnwYixcvBgAsW7YMDQ0NePXVVwHYDchrr70WTz31FEaMGOGccTSZTEhLSwMA3H777Rg7diwee+wxzJo1C++99x4+/fRTbNmyJTKZBBmRqiYvNQHX9LKhX6G7QSN39sThXaPhcHC19+iGVBaN7eHz2RWDi/y+q9Nq8Mil/Xw+D+ea7kCikttgPTBDAUNOJMpeOcn44+xBXu5yLyEPJ3zRpyRETv0svbhU3JNEJvbNxcS+3p36WBjFlsLQkkx8uLsx0skIKZ46Q8PZv/FgjMjHrxwoaEQmGXVYfbm3oWfUaZCg12LVZYEZgRzHYdHYHhgwoGsA77oG0nrlJGPN7IFuzwcXZ2BwcUZA6Yp2umUm4vBp6UuHpeqFwiT5RtKMAfmS/OWkJuCJKweKe5SAvD2RHJZNL/Nyc7SXK/+5V3q80qNVNYO6pWPz/pMhC5/jONxfbZc5GZHhY86cOTh16hRWrlyJxsZG9OvXDzU1NSgutg/cNDY2ut0Z+dxzz8FiseDWW2/Frbfe6nRfsGAB1q1bBwAYOXIk3nzzTTz44IN46KGH0LNnT7z11lsYPnx4WPPGh4zIOCBeOrOhJBINVqBLaKNln1+UJFO1qGUknsrRjjpKIzRwiO38RRNq0+9KbvVQ47YRB6GSu5UOXIhZbrnlFtxyyy2CzxyGoYMvvvhCUphXXHEFrrjiiiBTphyRX1tGBIRb/1H05FOVtToqREyNR6K/Hmic0XJ4QazXy1BXGZXYkHFCbNdVMQL6VuOkgso1fIRPKFUoMUTICFUZWciIJKIYMiKjFFl3M4UsFdFJIPKIxMm2gcapZtvM7YAIFaeTkE6sDwYA3nVVLM9qHsgJpLzUm5v4Q3VlEcM2UDhUm8VqE/dEEColaozIRx99FCNHjkRiYiLS09MF/Rw+fBgzZ85EUlISsrKysHTpUnR2doY3oSokDvp4IScSI8WBDlBScROEsnh+U0JLifluoViWF8nvmtqQ0BLN8o2UDRkrs7e0nJWIZqJmT2RnZyeuvPJKVFVV4cUXX/R6brVaMWPGDGRnZ2PLli04deoUFixYAMYYnnnmmQikOLTI2w8VxS1UmBCTZ0T2RMbgTCShHGrpelB1Cw9KzfgGNBPJyd8VqZb6GWrkqmk1z1IHQqwYc2KEql2l5axENBM1RuTDDz8MwHszqoNPPvkEe/fuxZEjR1BQUAAAWLNmDRYuXIhHH31U9HLQWEbBq/DilkgcYhJ42xIdBR4dqVQvaum8xcOghdw8qsFQ0Ol0sFiUuTog8rmJb9yOQFBZYSh6sI5KdFo4oZlIIpqJGiNSjK1bt6Jfv35OAxIApk6dio6ODuzcuRMTJkwQfK+jowMdHa47zlpbWwEAFosFZrM5tIkWwRG/ZzrMZjMsVqvzt433t+e7dljE8yIXoTwH8r7QezZm83K38mQo9I7FapWVBiXk3Wk2w2zWyn7PJjOtQviTXzBhWj3qarTVS7mEMn9idTZcMF4nKBbK07Pum81mwUEkz7zabHy9It4xlKvjbDbp37XZbEafPn1QV1cHm83m9czTTSwsvuEiNQ1qqZ8hR8Ty8c67d3tstvgvD8YrL7PZ98BAJORssQTf3jiQUy/5+PqWgk0X/7u3+JB7sHF47okMdxmq9dsMRR8kGJQakIs1YsaIbGpqQm6u+11tGRkZMBgMzks7hVi1apVzlpPPZ599hqysLMXTGQgbNmzA1CINPj6qwahcG2pqatDWDjiK7/yhb9A/Q4O6X1xbXGtqalDZRYP/ntKgNxpRU3MsMomXQbJei7Nme2+lpqYGFxdo8NkxjfN3IGzYsMH5d55Ji6bzHHLbj6Cm5rCbP4c8NWDOuLomaXHk3IXeU+Ne1NSI3WFlL4/SVFvA6XWkEQC2b/4cehm7lrMTtDjVAZzc9zVqDgYUvRd8+QXCqFwN/nNcg6mFdpm0dAIOOc0oaA9YTurGnr8re9iClp8/jOfscaXoWUTl2NXCAdCiPD3weh957GU2INM7Dxs2bEB3mz2PDqYVWe13fiVrceis/Xtlx/agpmYPAKC/gcPWC/57p9lw1szhWJvLEjNqHGVmjzc/UbgM+frAfPRb1Jz61m/6ASDX5B5Wa2srjh8/7vzd0NAArdb/4FR1Vw41R+x+ampqMCmfwweHtRiWLb2MuXaAgxZdkwLX35HBJcusBIaT7f6n/kZknMPfm33L05H3QV002HVKg1GZbV7ysI/DuHfHshNcf+efrwcHLXJNQN1Xm5x+uxgZTnW40hdOOXcxatHcCRzb8xVq9ikTZuZZQGq39FfdrPjgsBaVXXzXyWD1L+OVS932TeiZosWPre71IViZT+rC4cDP9vozrSi0OrQsXYPvml2diuyEyLYdUghlGyqHkydDd5dnNMOxCF42tmLFCkEDjs+OHTswZMgQ5+9169bhjjvuQHNzs5u/G2+8EYcOHcLHH3/s5m4wGPDqq69i7ty5guF7zkQ2NDSgvLwc9fX1KCwslJkjZTGbzdiwYQMmT54MnU6H/SfOold2MjQX1qd+12ifNS3LT4HFakP9yTYcbT6Pi7qmIz1Rjw6LDUd/OY+e2UmRzIZkzFYbNu07iaqemUg06GCzMXz+w88Y1DUNWclGeWHxZKfX6wEA7WYrGs+0oyRLWB5HfmlDusmAlAR7o9FhtmLfibNINelRnJkoGme72YqNP/yMaRW5Ae9f6jBbsbuhBcVdEpGTIi/PZ86b0dJuRtcM8bSKISS/QLDZGA78fBalOclOmew60ozGM+2Y3i8v6HSqkZNnO/Dt0Wa0/bQzaPmJcehUG7JTDEg0RHY8cP+JsyhKN8FkkD9zrgZa2y34qv40JvbJdupXz2/gp5/PIT8tAUd+aXPW5w6LDfuOtyLNpEc3Dx2x//hZmG029MpOhl7L4eO9JzC+dxZOtHYgM8mAZKMO5zut2HzgJCb1zXHGy6flvBmNZ9phMmi9wufTYbHhs+9OoG9eCgrSE5Cgd5VDa2sr9u/f7/xdWVkpSSYbf/jZ2ZYwxnDgxDn0yE6CVuL+CLPZjDf+uQEzp0xARrJJ0jtq4NDpNryw5SBWzizDmfMWnGk3Y8PeE/jx53O4dkQ32BhD79xkfP79z5jQJxt6LYcDP59DSZdEbKv/Bb1zk5Fo0OJvXx/F7CFFSDbav01HG90rJ0mwfTh1rhMWqw0GnQZnz3eg7qvNGDpqPCzQID8tAYdPtyHdpEeqSY/jLe3QaTVI1GtxvLUdRp0WCXoNMhINYZNTc5sZ5zotKExXtmwPnjqH3JQE7DrajOLMRJztsGDG/9vqfP769UNQmG5CQVoCDpw4h5KsROi07qOtSrVfgKtcclMT0Gmx4fDpNhSkJ+Cv24/iqqFFSDIGr3vf/6YRFpsNvx5UENLTrm02ho/2HEdhegIaz7RjYp9sGPXq1NlKlqESNDQ0oKSkBEeOHEFRUVGkk6MaItrzWLJkiU/jzkH37t0lhZWXl4evvvrKze2XX36B2Wz2mqHkYzQaYTS6OustLS0A7PtJ1FBxAUCv10Ov16OiKNPNfUC3TJ4foLzIiPKiDDe3viZ5hkgk0euBaQPcDffpA4Iz5B2yc/ydkpjg02+PnDSvdyu7+/YvFNclF3UNLKG8MEaWSo+TT5ZejyyFt/7y5RconvV2aI/soMJTO/kZemQlG1HzkzLy80evvDRxT2GgvDBD3JOKydTrfeoaRxn2KUgHAFQkJfCeAZXdhXUsXxcDwMxB9o4HXwfp9XrMGOi7Q9JFr0eXVPFBIb0emFUprHuMRiN0OntTn5OTI7k+TulX4Pa7vEi+gZKVAGQkm1TTlkqhV24aVl8+EACQbTAgO83u5smvBrnKrbzQLpsJZa6BsZvGl7r5d7TRvshLd8koI9GAOgDZaYlO2fXkpaGoi8tvalJg7UWwZKfpEQpNXpqXDgAY20d4kHFUqas/J1YnldC//HLR64GyQnsZ3jyh1Ncrsrl8SDfFwhLjUh96Qq2Eug2VikOHEu5EVCpZWVmKLRmtqqrCo48+isbGRuTn5wOwH7ZjNBoxePBgReIgCIIgiGiira3N+bev67EIgiAIQi5RY1ofPnwYp0+fxuHDh2G1WrFr1y4AQK9evZCcnIwpU6agvLwc8+fPx+OPP47Tp0/j7rvvxqJFi+L6ZFaCIAgifgnl8jiCIAgifokaI/J3v/sdXnnlFefviy66CACwceNGjB8/HlqtFh9++CFuueUWjBo1CiaTCVdffTWeeOKJSCWZIAiCICJKUlJ07IknCIIgoouoMSLXrVvn845IB926dcMHH3wQngQRBEEQhMrh7/k/c+YMUlJSIpgagiAIIlaQcYEAQRAEQRDRBH85Ky1tJQiCIJSCjEiCIAiCiFH4hiOdD0AQBEEoBRmRBEEQBBEHaDTU5BPRR5rpwjVdWppJJwg1QS0KQRAEQcQwBQUF6NKlCx2yQ0QlbywagbG9s7H+5lGRTgpBEDyi5mAdgiAIgiDk47g7mSCikfKCVLz6P8MinQyCIDygmUiCIAiCIAiCIAhCMmREEgRBEARBEARBEJIhI5IgCIIgCIIgCIKQDBmRBEEQBEEQBEEQhGTIiCQIgiAIgiAIgiAkQ0YkQRAEQRAEQRAEIRkyIgmCIAiCIAiCIAjJ0D2RHthsNgBAY2NjhFMCWCwWnDx5Eg0NDdDpqKjkQLILDpJfcJD8oh8qw+Ag+QUOyS44SH7Rj9rK0GETOGwEwk7kS0ZlHD9+HAAwbBhdbEsQBEEQBEEQhN1G6NatW6SToRo4xhiLdCLUhMViQW1tLXJzc6HRRHa1b2trK8rLy7F3716kpKRENC3RBskuOEh+wUHyi36oDIOD5Bc4JLvgIPlFP2orQ5vNhuPHj+Oiiy5SxcyoWiAjUsW0tLQgLS0NZ86cQWpqaqSTE1WQ7IKD5BccJL/oh8owOEh+gUOyCw6SX/RDZRgd0ME6BEEQBEEQBEEQhGTIiCQIgiAIgiAIgiAkQ0akijEajVi+fDmMRmOkkxJ1kOyCg+QXHCS/6IfKMDhIfoFDsgsOkl/0Q2UYHdCeSIIgCIIgCIIgCEIyNBNJEARBEARBEARBSIaMSIIgCIIgCIIgCEIyZEQSBEEQBEEQBEEQkiEjkiAIgiAIgiAIgpAMGZEEQRAEQRAEQRCEZMiIBLBq1SoMHToUKSkpyMnJwaWXXooffvjBzQ9jDCtWrEBBQQFMJhPGjx+PPXv2OJ+fPn0at912G/r06YPExER069YNS5cuxZkzZwTj7OjowKBBg8BxHHbt2iWaxrq6OowbNw4mkwmFhYVYuXIl+AfrLly4EBzHef2rqKgQDXvt2rUoKSlBQkICBg8ejM2bN7s9X79+PaZOnYqsrCyv9JLs/Mvu7NmzWLJkCYqKimAymVBWVoZnn32W5Adg06ZNmDlzJgoKCsBxHP7xj394+REKe8SIEXEvO7G8m81m/Pa3v0X//v2RlJSEgoICXHvttTh27JhomsNNLJQjALz++usYOHAgEhMTkZ+fj+uuuw6nTp0SDTve9S8QOtnFg/4FApMf6d/AZUf6V33l+Kc//QllZWUwmUzo06cPXn31VUn5D0b/EgAYwaZOncpefvll9u2337Jdu3axGTNmsG7durGzZ886/axevZqlpKSwd955h9XV1bE5c+aw/Px81tLSwhhjrK6ujl122WXs/fffZwcOHGCfffYZKy0tZZdffrlgnEuXLmXTp09nAFhtba3f9J05c4bl5uayuXPnsrq6OvbOO++wlJQU9sQTTzj9NDc3s8bGRue/I0eOsMzMTLZ8+XK/Yb/55ptMr9ezv/zlL2zv3r3s9ttvZ0lJSezQoUNOP6+++ip7+OGH2V/+8hev9JLs/MvuhhtuYD179mQbN25k9fX17LnnnmNarZb94x//iHv51dTUsAceeIC98847DAB79913vfwsWLCATZs2zS38U6dOxb3sxPLe3NzMJk2axN566y32/fffs61bt7Lhw4ezwYMH+w03EsRCOW7evJlpNBr21FNPsZ9++olt3ryZVVRUsEsvvdRv2KR/Qyu7eNC/gcqP9G/gsiP9q65yXLt2LUtJSWFvvvkm+/HHH9kbb7zBkpOT2fvvv+837GD1L8EYGZECnDhxggFg//73vxljjNlsNpaXl8dWr17t9NPe3s7S0tLYn//8Z5/h/O1vf2MGg4GZzWY395qaGta3b1+2Z88eSZVy7dq1LC0tjbW3tzvdVq1axQoKCpjNZhN8591332Ucx7GDBw/6DXvYsGFs8eLFbm59+/Zl9913n5ff+vp60fSS7NxlV1FRwVauXOnmp7Kykj344IOCYcaT/Pj468TMmjVLUhjxKjvGvPMuxPbt2xkAtwZSjURjOT7++OOsR48ebu89/fTTrKioyG/YpH9DK7t40L+Byo9PvOpfJWTHGOlfIcJZjlVVVezuu+92e+/2229no0aN8hu20vo3HqHlrAI4puAzMzMBAPX19WhqasKUKVOcfoxGI8aNG4cvv/zSbzipqanQ6XROt+PHj2PRokV47bXXkJiYKCk9W7duxbhx42A0Gp1uU6dOxbFjx3Dw4EHBd1588UVMmjQJxcXFPsPt7OzEzp073fIFAFOmTPGbL3+Q7NxlN3r0aLz//vtoaGgAYwwbN27Evn37MHXqVMFw40V+cvjiiy+Qk5OD3r17Y9GiRThx4oSgv3iWnWfeffnhOA7p6emywg430ViOI0eOxNGjR1FTUwPGGI4fP46///3vmDFjhs9wSf8eBBBa2cWD/g1EfnKIZf2rlOxI/wqHE65y7OjoQEJCgtt7JpMJ27dvh9lsFgw3FPo3HiEj0gPGGO666y6MHj0a/fr1AwA0NTUBAHJzc9385ubmOp95curUKTzyyCO46aab3MJeuHAhFi9ejCFDhkhOU1NTk2Dc/LTxaWxsxEcffYQbbrjBb7gnT56E1WqVlS9/kOy88/X000+jvLwcRUVFMBgMmDZtGtauXYvRo0d7hRlP8pPK9OnT8frrr+Pzzz/HmjVrsGPHDkycOBEdHR1u/uJZdkJ596S9vR333Xcfrr76aqSmpsoKP5xEazmOHDkSr7/+OubMmQODwYC8vDykp6fjmWee8Rku6d/Qyy4e9G8g8pNKrOtfJWRH+tebcJfj1KlT8cILL2Dnzp1gjOHrr7/GSy+9BLPZjJMnTwqGq7T+jVfIiPRgyZIl2L17N9544w2vZxzHuf1mjHm5AUBLSwtmzJiB8vJyLF++3On+zDPPoKWlBcuWLfMZf0VFBZKTk5GcnIzp06f7jVvIHQDWrVuH9PR0XHrppU63zZs3O8NNTk7G66+/LjtfYpDsvPP19NNPY9u2bXj//fexc+dOrFmzBrfccgs+/fRTr7jjUX5izJkzBzNmzEC/fv0wc+ZMfPTRR9i3bx8+/PBDN3/xLDt/eQfshzzMnTsXNpsNa9eu9ZkHNRCt5bh3714sXboUv/vd77Bz507861//Qn19PRYvXgyA9K9n3Hz3UMouHvRvMPITI9b1rxKyI/3rTiTK8aGHHsL06dMxYsQI6PV6zJo1CwsXLgQAaLXasOjfeEUn7iV+uO222/D+++9j06ZNKCoqcrrn5eUBsI965OfnO91PnDjhNYrR2tqKadOmITk5Ge+++y70er3z2eeff45t27a5TcsDwJAhQ3DNNdfglVdeQU1NjXP63WQyOeP3HBlxLCnxjJ8xhpdeegnz58+HwWBwi4N/qlRubi6MRiO0Wq1g2J7hikGy887X+fPncf/99+Pdd991Lo8ZMGAAdu3ahSeeeAKTJk2KW/kFSn5+PoqLi7F//36nWzzLzlfeHZjNZsyePRv19fX4/PPPVT0KHs3luGrVKowaNQr33HMPAPt3npSUhDFjxuD3v/896V+P/DlkAIROdvGifwORX6DEmv4NVnakf9VRjiaTCS+99BKee+45HD9+HPn5+Xj++eeRkpKCrKwspKSkhFT/xjVKbrCMVmw2G7v11ltZQUEB27dvn+DzvLw89thjjzndOjo6vDYWnzlzho0YMYKNGzeOnTt3ziucQ4cOsbq6Oue/jz/+mAFgf//739mRI0d8pm/t2rUsPT2ddXR0ON1Wr14teEDHxo0bGQBWV1cnKe/Dhg1jN998s5tbWVmZ5I3FJDvfsjtz5gwDwGpqatz83HjjjWzy5MmMsfiWHx/4ONjBk5MnTzKj0cheeeWVuJadWN4ZY6yzs5NdeumlrKKigp04cUJSuJEgFsrxsssuY7Nnz3Z778svv2QAWENDg8+wSf+GTnbxon8DlR+feNW/gcqO9K+6ylGIsWPHsquuuspv3oPVvwSdzsoYY+zmm29maWlp7IsvvnA7yrqtrc3pZ/Xq1SwtLY2tX7+e1dXVsauuusrtiOOWlhY2fPhw1r9/f3bgwAG3cCwWi2C8Uitlc3Mzy83NZVdddRWrq6tj69evZ6mpqW5HHDuYN28eGz58uOS8O444fvHFF9nevXvZHXfcwZKSktxOhzx16hSrra1lH374IQPA3nzzTVZbW8saGxtJdiKyGzduHKuoqGAbN25kP/30E3v55ZdZQkICW7t2LWMsvutea2srq62tZbW1tQwA++Mf/8hqa2udp9e1tray3/zmN+zLL79k9fX1bOPGjayqqooVFhaylpaWuJadWN7NZjO75JJLWFFREdu1a5ebH35jrAZioRxffvllptPp2Nq1a9mPP/7ItmzZwoYMGcKGDRvmN2zSv6GVXTzo30DlR/o3cNmR/lVXOf7www/stddeY/v27WNfffUVmzNnDsvMzGT19fV+ww5W/xJkRDLG7KNwQv9efvllpx+bzcaWL1/O8vLymNFoZGPHjnWbNXDMJAj981WR5Yxs7N69m40ZM4YZjUaWl5fHVqxY4TUK09zczEwmE3v++edl5f9Pf/oTKy4uZgaDgVVWVnodU/3yyy8L5mv58uUkOxHZNTY2soULF7KCggKWkJDA+vTpw9asWeOMP57l5yvdCxYsYIwx1tbWxqZMmcKys7OZXq9n3bp1YwsWLGCHDx+Oe9mJ5d2RRqF/GzdulBxPOIiVcnz66adZeXk5M5lMLD8/n11zzTXs6NGjomGT/g2d7OJF/wYiP9K/gcuO9K+6ynHv3r1s0KBBzGQysdTUVDZr1iz2/fffS8p/MPqXYIxj7MIOVYIgCIIgCIIgCIIQgU5nJQiCIAiCIAiCICRDRiRBEARBEARBEAQhGTIiCYIgCIIgCIIgCMmQEUkQBEEQBEEQBEFIhoxIgiAIgiAIgiAIQjJkRBIEQRAEQRAEQRCSISOSIAiCIAiCIAiCkAwZkQRBEARBEARBEIRkyIgkCIIgCIIgCIIgJENGJEEQBEEQBEEQBCEZMiIJgiAIgiAIgiAIyfz/+p4FYENEBB8AAAAASUVORK5CYII=",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"stats.plot()"
]
},
{
"cell_type": "markdown",
"id": "2ab01651-dd68-4555-b9b4-4a3d9c30ab29",
"metadata": {},
"source": [
"You can also explore more sophisticated approaches, such as dynamically controlling the `qty_threshold` and integrating it with the skew value, for example, `qty_threshold * (1 ± skew_val)`, similar to how skew is applied to the price. In other words, in the previous example, the spread is set in terms of price, but you can set the spread in terms of queue such as the queue position, the queue behind the order, the total queue, etc.\n",
"\n",
"Additionally, instead of reacting at fixed intervals, it may be more effective to respond to each incoming feed. This allows for faster reactions when the quantity at the BBO decreases rapidly, helping to avoid adverse selection. You can test this approach using the `wait_next_feed` method."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.10.14"
}
},
"nbformat": 4,
"nbformat_minor": 5
}